home *** CD-ROM | disk | FTP | other *** search
/ No Fragments Archive 12: Textmags & Docs / nf_archive_12.iso / MAGS / SOURCES / ATARI_SRC.ZIP / atari source / BODI / REDRAW.C < prev    next >
Encoding:
C/C++ Source or Header  |  2001-02-10  |  79.8 KB  |  3,170 lines
  1. /**************************************************************************/
  2. /*  FILE:  REDRAW.C        PROGRAM TITLE: DeskSET II Alpha Version   */
  3. /*  Date Created: 12/15/87                          */ 
  4. /*  Last Modified: 06/30/89                          */
  5. /*                                      */
  6. /*  Description: REDRAW ROUTINES                      */
  7. /*  Routines:     o  do_redraw()      - Event Redraw Routine          */
  8. /*        o  text_draw()    - Txt Window Redraw Routine          */
  9. /*        o  prev_draw()      - Preview Window Redraw Routine      */
  10. /*        o  pdraw_fit()    - Draw Preview Background (size to fit) */
  11. /*        o  pdraw_scale()  - Draw Preview Background (any scale)   */
  12. /*        o  rc_equal()      - Equal Rectangle Check          */
  13. /*        o  send_redraw()  - Self Redraw Routine              */
  14. /*        o  set_clip()      - Set Clip Rectangle              */
  15. /*        o  clear_window() - Clear Text and Preview Windows        */
  16. /*        o  redraw_images()- Redraw Images Routines          */
  17. /*        o  zoom_setup()   - Closes/Opens Preview Buffer          */
  18. /*        o  do_blit()      - Performs blit from Preview to Screen  */
  19. /*        o  mclip()      - set clip in preview buffer          */
  20. /*        o  scan_clip()    - set clip in scan buffer          */
  21. /*        o  redraw_laser() - Redraw Laser Buffer at curr_page      */
  22. /*        o  do_update_text()- update text ptrs for vgtext      */
  23. /*        o  graphic_setup() - Display or hide graphic images      */
  24. /*        o  force_preview() - Redraw preview window - immediate    */
  25. /*        o  force_blit_redraw() - Another force redraw message     */
  26. /*        o  recalc_txtptrs()- Recalc txt ptrs for dotext       */
  27. /*        o  recalc_rtext()  - Only recalc 1 articles reg. textptrs */
  28. /*        o  clear_preview() - Clear preview window          */
  29. /*         o  update_preview_blit() - Update blit rectangles         */
  30. /*        o  update_size_fit() - Update window params in size to fit*/
  31. /*        o  init_rulers()   - Initialize h and v rulers        */
  32. /*        o  init_hrulers()  - Initialize horizontal rulers      */
  33. /*        o  init_vrulers()  - Initialize vertical rulers          */
  34. /*        o  init_hinches()  - Initialize h ruler to inches      */
  35. /*        o  init_hpicas()   - Initialize h ruler to picas      */
  36. /*        o  init_hcents()   - Initialize h ruler to centimeters    */
  37. /*        o  init_vinches()  - Initialize v ruler to inches      */
  38. /*        o  init_vpicas()   - Initialize v ruler to picas      */
  39. /*        o  init_vcents()   - Initialize v ruler to centimeters    */
  40. /*        o  show_rulers()   - Show rulers on screen           */
  41. /*        o  do_grids()       - Display grids on screen          */
  42. /*        o  put_mpix()       - Put grid pixel in memory buffer      */
  43. /*        o  calc_size_fit() - Calc size of page for STF and PADJCNT*/
  44. /*        o  redraw_alt()       - Redraw Handler for PADJCNT          */
  45. /**************************************************************************/
  46.  
  47. /**************************************************************************/
  48. /* HISTORY                                  */
  49. /*                                       */
  50. /* 11/07/89  -  Replace all scale_iv() calls with scaler()          */
  51. /*        calc_size() -   "          "        "                     */
  52. /*        repel_images() - "         "        "                     */
  53. /*                                      */
  54. /* 11/07/89  -  Replace all hmutopix() calls with hmupix()          */
  55. /*         pdraw_scale()  -   "       "        "              */
  56. /*        calc_size_fit()-   "       "        "                     */
  57. /*                                      */
  58. /* 11/07/89  -  Replace all vmutopix() calls with vmupix()          */
  59. /*        pdraw_scale() - replace vmutopix() with vmupix()       */
  60. /*        do_update_text() - replace vmutopix() with vmupix()      */
  61. /*        do_artcleanup()  - replace vmutopix() with vmupix()      */
  62. /*        calc_size_fit()  - replace vmutopix() with vmupix()       */
  63. /**************************************************************************/
  64.  
  65.  
  66. /**************************************************************************/
  67. /* INCLUDE FILES                              */
  68. /**************************************************************************/
  69. #include <obdefs.h>
  70. #include "define.h"
  71. #include "gemdefs.h"
  72. #include "deskset2.h"
  73. #include <osbind.h>
  74. #include "defs.h"
  75. #include "dbase.h"
  76. #include "alert.h"
  77.  
  78. /**************************************************************************/
  79. /* DEFINES                                  */
  80. /**************************************************************************/
  81. #define max(x,y)   (((x) > (y)) ? (x) :  (y))    /* Max function              */
  82. #define    min(x,y)   (((x) < (y)) ? (x) :  (y))    /* Min function          */
  83.  
  84.  
  85. /**************************************************************************/
  86. /* EXTERNALS                                  */
  87. /**************************************************************************/
  88. extern int gl_apid;                /* gl_apid used for redraw*/
  89.  
  90. extern int txt_handle;                /* text window handle     */
  91. extern int prev_handle;                /* preview window handle  */
  92. extern int dummy;                /* dummy, you dummy...    */
  93.  
  94. extern GRECT dpwork;                /* work area of window    */
  95. extern GRECT pwork;                /* preview window wrk area*/
  96. extern GRECT twork;                /* txt window work area   */
  97.  
  98. extern int phandle;                /* printer handle         */
  99. extern int mhandle;                /* preview buffer handle  */
  100. extern int shandle;                             /* screen handle          */
  101.  
  102. extern int view_size;                /* Current Viewing Size   */
  103.  
  104. extern int hpage_size;                /* Horiz Page Width -MU   */
  105. extern int vpage_size;                /* Vert. Page Width - MU  */
  106. extern FDB page_MFDB;                /* Preview Buffer MFDB    */
  107. extern GRECT page_area;             /* Preview BUffer GRECT   */
  108. extern long location;                /* Screen MFDB          */
  109.  
  110. extern int ptsin[];                /* PTSIN array for data   */
  111. extern int intout[];
  112.  
  113. extern long get_fregion();            /* get first region      */
  114. extern long get_nregion();            /* get next region        */
  115. extern long getf_aregion();            /* get first article reg..*/
  116. extern long getn_aregion();            /* get next article region*/
  117. extern long getf_article();
  118. extern long getn_article();
  119. extern long get_regart();
  120. extern SCANINFO *getf_scaninfo();
  121. extern SCANINFO *getn_scaninfo();
  122.  
  123. extern curr_page;                /* current page          */
  124.  
  125. extern int rect_in_mu[];;            /* x1,y1,x2,y2 variables  */
  126. extern int mode_flag;                /* current fill mode      */
  127. extern int msg_buff[];                /* evnt_multi buffer      */
  128.  
  129. extern unsigned long scanptr;            /* Ptr to Scan Buffer     */
  130. extern unsigned long page_ptr;            /* Ptr to Preview Buffer  */
  131. extern unsigned long pageim;            /* Ptr to Laser Buffer    */
  132. extern int mxres,myres;                /* Preview Buffer rez     */
  133. extern int mode_change;                /* Flag - just change     */
  134.                         /* fill type????  0 no    */
  135.                         /*          1 yes   */
  136. extern unsigned long prev_bytes;        /* #bytes in preview buf  */
  137. extern unsigned long laser_bytes;
  138. extern unsigned long scan_bytes;
  139.  
  140. extern int scan_xres;                /* scan buffer xres      */
  141. extern int scan_yres;                /* scan buffer yres      */
  142.  
  143. extern int  zdevice;                /* index into xdpi/ydpi   */
  144. extern int  pxy[];                /* tmp array          */
  145.  
  146. extern char *do_handjreg();            /* Do jim's scan routine  */
  147. extern char *get_arttxt();            
  148. extern char *get_txtptr();
  149. extern int  SH;                    /* Line space for scanner */
  150.  
  151. extern int ptsarray[];                /* Interface to DBASE.C   */
  152. extern unsigned long gl_region_ptr;        /* txt region pointer...  */
  153. extern int cur_primitive;            /* current primitive RCS  */
  154. extern int image_status;            /* Image Display? or not..*/
  155.  
  156. extern struct txtattr gltxtattr;        /* global text attrib     */
  157. extern int glgrattr[];                /* global graphic attrib  */
  158.  
  159. extern int sdevm;
  160.  
  161. extern int xruler_offset;
  162. extern int yruler_offset;
  163. extern int ruler_flag;
  164. extern int unit_type;
  165. extern int splane;
  166. extern unsigned long scanptr;
  167. extern int newx,newy;
  168. extern int xold_mark,yold_mark;
  169. extern int xor_handle;
  170. extern char *get_lcmem();
  171. extern int rule_handle;
  172. extern int deferhj;
  173. extern int show_grids;
  174. extern int hgridspace;
  175. extern int vgridspace;
  176.  
  177. extern long pagebytes;
  178.  
  179. extern int print_flag;
  180.  
  181. extern    int    TWrfmod;            /* TWindow refresh mode    */
  182. extern    long    TWart_ptr;            /* TW current article    */
  183.  
  184. extern PAGE *curpage;
  185. extern long curregion;
  186.  
  187.  
  188. extern PAGE *pagehd;
  189. extern PAGE *left_tmplate;
  190. extern PAGE *right_tmplate;
  191. extern int tmplate_flag;
  192. extern int temp_page;
  193. extern PAGE *tpagehd;
  194. extern PAGE *tcurpage;
  195. extern int displ_tmpl_flag;
  196. extern int disp_pos;                /* template-FRONT or BACK   */
  197. extern int disp_type;                /* templ type-BOTH,LEFT,RITE*/
  198.  
  199. extern ARTICLE *rtarthd;
  200. extern ARTICLE *ltarthd;
  201. extern ARTICLE *arthd;
  202.  
  203. extern int TYF_Gx0;
  204. extern int TYF_Gy0;
  205. extern int TYF_Gx1;
  206. extern int TYF_Gy1;
  207. extern int TYF_Gtype;
  208. extern char *TYF_Gfile;
  209.  
  210. extern unsigned char *buf_end;
  211. extern long    curart;
  212. extern int mnumfnt;            /* Number of fnts in mem driver   */
  213. extern long daveptr;
  214. extern int pagetype;
  215. extern int pxres;
  216. extern int pyres;
  217.  
  218. extern char cpabt;            /* DOTEXT VARIABLE CJG 08/26/89   */
  219.  
  220. /**************************************************************************/
  221. /* GLOBAL VARIABLES                              */
  222. /**************************************************************************/
  223. char *savecptr;
  224. int pagew;                    /* Current Page width and */
  225. int pageh;                    /* height in pixels for   */
  226.                         /* reference purposes only*/
  227. int opwidth;                    /* Old page width pixels  */
  228. int opheight;                    /* Old page ht - pixels   */
  229.  
  230. int clip_area[4];                /* Global Clipping rect.  */
  231.  
  232. unsigned long region_ptr;            /* Ptr to current region  */
  233.  
  234. int  opcode;                    /* opcode of poly type    */
  235. int  count;                    /* number of vertices     */
  236. int  wmode;                    /* writing mode          */
  237.  
  238. int txoffset,tyoffset;                /* tmp xoffset and yoffset*/
  239. int prev_size;                    /* preview size          */
  240. int blit_flag;                    /* to blit or not to blit */
  241. int xwidth,ywidth;                /* Calc screen width/ht   */
  242.  
  243. char *txtptr;                    /* Text Pointer...        */
  244. GRECT page;                    /* GRECT of page area?    */
  245. int force_draw_flag;                /* Force a redraw on Prev.*/
  246. int blit_area[8];
  247. int aclear[4];                    /* preview clear_window rect*/
  248. int aclear2[4];
  249.  
  250. int *hrbuffer;
  251. int *vrbuffer;
  252. FDB hrule_mfdb;
  253. FDB vrule_mfdb;
  254. int vhalf,hhalf;
  255. int hlen,vlen;
  256. int x_eighths,y_eighths;
  257.  
  258. int ruler_hasmem;
  259.  
  260. char pixtbl[] = {0x80,
  261.          0x40,
  262.          0x20,
  263.          0x10,
  264.          0x08,
  265.          0x04,
  266.          0x02,
  267.          0x01};
  268.  
  269. int alt_offset;
  270.  
  271.  
  272. long newscreen;
  273. long realscreen;
  274. int alerted;
  275.  
  276.  
  277. unsigned long pgeptr;            /* equal to page_ptr in do_grids*/
  278.  
  279. /**************************************************************************/
  280. /* Function:    do_redraw()                          */
  281. /* Description: Event Driven Redraw Routine                  */
  282. /**************************************************************************/
  283. do_redraw(msg)
  284. register int msg[];
  285. {
  286.    register int whandle;
  287.    GRECT t1,t2;
  288.    int pxy[4];
  289.  
  290.    gsx_moff();
  291.    whandle = msg[3];
  292.    t2.g_x  = msg[4];
  293.    t2.g_y  = msg[5];
  294.    t2.g_w  = msg[6];
  295.    t2.g_h  = msg[7];
  296.  
  297.    if(whandle == txt_handle)
  298.    {
  299.       if (!TWart_ptr || TWrfmod == 2)        /* force full TW area    */
  300.       {
  301.       t2.g_x = twork.g_x;
  302.       t2.g_y = twork.g_y;
  303.       t2.g_w = twork.g_w;
  304.       t2.g_h = twork.g_h;
  305.       }
  306.       if (TWart_ptr)
  307.       {
  308.       clrcursor();
  309.       hilicheck(0);
  310.       review(TWrfmod);
  311.       }
  312.  
  313.    }
  314.    wind_get(whandle,WF_FIRSTXYWH,&t1.g_x,&t1.g_y,&t1.g_w,&t1.g_h);
  315.    while(t1.g_w && t1.g_h)
  316.    {  
  317.       gsx_moff();
  318.       if(rc_intersect(&t2,&t1))
  319.       {
  320.          set_clip(TRUE,&t1);
  321.      grect_to_array(&t1,pxy);        /* experimental */
  322.      vs_clip(rule_handle,1,pxy);
  323.  
  324.          if(whandle ==  txt_handle)
  325.      {
  326.             txt_draw(&t1);
  327.         set_clip(FALSE,&t1);
  328.          }
  329.          else
  330.             if(whandle == prev_handle) 
  331.              prev_draw();
  332.       }
  333.       wind_get(whandle,WF_NEXTXYWH,&t1.g_x,&t1.g_y,&t1.g_w,&t1.g_h);
  334.    }
  335.  
  336.    if (whandle == txt_handle && TWart_ptr)
  337.    {
  338.     endreview(0);
  339.     cursor();
  340.     if (TWrfmod <= 2) TWrfmod = 3;
  341.    }
  342.  
  343.    vs_clip(rule_handle,0,pxy);
  344.    check_region_ptr();
  345.    gsx_mon();
  346. }
  347.  
  348.  
  349.  
  350. /**************************************************************************/
  351. /* Function:    txt_draw()                          */
  352. /* Description: Redraw Txt Window                      */
  353. /**************************************************************************/
  354. txt_draw(rect)
  355. GRECT *rect;
  356. {
  357.    clrTW(rect);
  358.    if (TWart_ptr) new_screen();
  359. }
  360.  
  361.  
  362.  
  363. /**************************************************************************/
  364. /* Function:    prev_draw()                          */
  365. /* Description: Redraw Preview Window                      */
  366. /**************************************************************************/
  367. prev_draw()
  368. {
  369.    blit_flag = TRUE;
  370.    if(force_draw_flag)
  371.    {
  372.        blit_flag = FALSE;
  373.        force_draw_flag = FALSE;
  374.    }
  375.    clear_preview();
  376.    if(view_size == PADJCNT)
  377.         redraw_alt();
  378.    else
  379.            redraw_images();
  380. }
  381.  
  382.  
  383.  
  384.  
  385. /**************************************************************************/
  386. /* Function:    pdraw_fit()                          */
  387. /* Description: Calculate screen page width and height              */
  388. /**************************************************************************/
  389. pdraw_fit(item)
  390. int item;
  391. {
  392.     if(ruler_flag)
  393.          mutoscrn(648,576,&xruler_offset,&yruler_offset,1);
  394.     else
  395.          xruler_offset = yruler_offset = 0;
  396.     dpwork.g_x = pwork.g_x + xruler_offset;
  397.     dpwork.g_y = pwork.g_y + yruler_offset;
  398.     dpwork.g_w = pwork.g_w - xruler_offset;
  399.     dpwork.g_h = pwork.g_h - yruler_offset;
  400.     calc_size_fit(item);
  401. }
  402.  
  403.  
  404. /**************************************************************************/
  405. /* Function:    pdraw_scale()                          */
  406. /* Description: Draw the preview background page (any scale)          */
  407. /**************************************************************************/
  408. pdraw_scale()
  409. {
  410.       txoffset = page_area.g_x;
  411.       tyoffset = page_area.g_y;
  412.  
  413.       zdevice  = SCREEN;
  414.       pagew = hmupix(hpage_size);        /* can make this a variable */
  415.       pageh = vmupix(vpage_size);        /* for later...            */
  416.  
  417.       scale(&pagew,&pageh,&txoffset,&tyoffset,0);
  418.  
  419.       pxy[0] = pwork.g_x + hmupix(txoffset);
  420.       pxy[1] = pwork.g_y + vmupix(tyoffset); 
  421.       xwidth = pxy[2] = pxy[0] + pagew - 1;
  422.       ywidth = pxy[3] = pxy[1] + pageh - 1;
  423. }
  424.  
  425. /**************************************************************************/
  426. /* Function:    rc_equal()                          */
  427. /* Description: check if 2 rectangles are equal                  */
  428. /**************************************************************************/
  429. rc_equal(p1,p2)
  430. register GRECT *p1,*p2;
  431. {
  432.     if((p1->g_x != p2->g_x) ||
  433.        (p1->g_y != p2->g_y) ||
  434.        (p1->g_w != p2->g_w) ||
  435.        (p1->g_h != p2->g_h))
  436.        return(FALSE);
  437.     return(TRUE);
  438. }
  439.  
  440.  
  441.  
  442. /**************************************************************************/
  443. /* Function:    send_redraw()                          */
  444. /* Description: Perform a self-redraw                      */
  445. /**************************************************************************/
  446. send_redraw(wh)
  447. int wh;
  448. {
  449.     msg_buff[0] = WM_REDRAW;
  450.     msg_buff[1] = gl_apid;
  451.     msg_buff[2] = 0;
  452.     msg_buff[3] = wh;
  453.     msg_buff[4] = pwork.g_x;
  454.     msg_buff[5] = pwork.g_y;
  455.     msg_buff[6] = pwork.g_w;
  456.     msg_buff[7] = pwork.g_h;
  457.     appl_write(gl_apid,16,msg_buff);
  458. }
  459.  
  460.  
  461.  
  462. /**************************************************************************/
  463. /* Function:    set_clip()                          */
  464. /* Description: Set a clipping Rectangle                  */
  465. /* INPUT: clip_flag o 0 - Clip Off  1 - Clip On                  */
  466. /*        area      0 Area to Clip                      */
  467. /**************************************************************************/
  468. set_clip(clip_flag,area)
  469. int clip_flag;
  470. GRECT *area;
  471. {
  472.      int pxy[4];
  473.  
  474.      grect_to_array(area,pxy);
  475.      vs_clip(shandle,clip_flag,pxy);
  476. }
  477.  
  478.  
  479.  
  480. /**************************************************************************/
  481. /* Function:    clear_window()                          */
  482. /* Description: Clears the window  - Text Window  to white          */
  483. /*                   - Preview Window to Dithered.          */
  484. /* INPUT: whandle - handle of window                          */
  485. /*      pattern - interior pattern                      */
  486. /*      style   - style type.                          */
  487. /**************************************************************************/
  488. clear_window(whandle,pattern,style)
  489. int whandle;
  490. int pattern;
  491. int style;
  492. {
  493.     int pxy[4];
  494.   
  495.     vsf_interior(shandle,pattern);
  496.     vsf_style(shandle,style);
  497.     vsf_perimeter(shandle,0);
  498.     if(whandle == prev_handle)
  499.     {
  500.          aclear[0] = dpwork.g_x + pagew;    /* clears right of page */
  501.      aclear[1] = pwork.g_y;
  502.          aclear[2] = aclear[0] + pwork.g_w - 1;
  503.          aclear[3] = aclear[1] + pwork.g_h - 1;
  504.  
  505.          aclear2[0] = pwork.g_x;        /* clears below of page */
  506.      aclear2[1] = dpwork.g_y + pageh;
  507.          aclear2[2] = aclear2[0] + pwork.g_w - 1;
  508.      aclear2[3] = aclear2[1] + pwork.g_h - 1;
  509.     }
  510.     else
  511.     {
  512.        grect_to_array(&twork,pxy);
  513.        vr_recfl(shandle,pxy);
  514.     }    
  515. }
  516.  
  517.  
  518. /**************************************************************************/
  519. /*    Clean up all rectangles of regions that have been re H&J ed       */
  520. /*    from the current article.  Start with the given region which was  */
  521. /*    the first one h&jed and clean up all other regions on the         */
  522. /*     same page.                              */
  523. /**************************************************************************/
  524. make_slave(rptr,stop_ptr)
  525. long rptr;
  526. long stop_ptr;
  527. {
  528.    register long region_ptr;
  529.    int rect[4];
  530.    int page;
  531.    long tmpregion;
  532.    int endflag;
  533.    long slvptr;
  534.    long ldummy;
  535.    int dummy;
  536.  
  537.    region_ptr = getf_aregion(&rect[0],&rect[1],
  538.                  &rect[2],&rect[3],&page);
  539.  
  540.    while(region_ptr != rptr && region_ptr)
  541.       region_ptr = getn_aregion(&rect[0],&rect[1],
  542.                     &rect[2],&rect[3],&page);    
  543.  
  544.    while(region_ptr && (region_ptr != stop_ptr))
  545.    {
  546.       getf_scaninfo(region_ptr,&dummy,&dummy,&dummy,&dummy,&ldummy,&slvptr);
  547.       if(page == curr_page && !slvptr)
  548.       {
  549.          get_txtattr(region_ptr,&gltxtattr);
  550.          tmpregion = curregion;
  551.      if(txtptr = get_txtptr(region_ptr))
  552.          {
  553.        if(*txtptr)
  554.        {
  555.          get_buffvars(region_ptr);
  556.          open_region(region_ptr);
  557.              do_slave_only(txtptr,&endflag);
  558. /*             put_buffvars(region_ptr);        */
  559.        }
  560.          }
  561.          curregion = tmpregion;
  562.       }
  563.       region_ptr = getn_aregion(&rect[0],&rect[1],
  564.                           &rect[2],&rect[3],&page);    
  565.  
  566.    }
  567. }
  568.  
  569. /**************************************************************************/
  570. /*    Clean up all rectangles of regions that have been re H&J ed       */
  571. /*    from the current article.  Start with the given region which was  */
  572. /*    the first one h&jed and clean up all other regions on the         */
  573. /*     same page.                              */
  574. /**************************************************************************/
  575. page_cleanup(rptr,stop_ptr)
  576. long rptr;
  577. long stop_ptr;
  578. {
  579.    register long region_ptr;
  580.    int rect[4];
  581.    int page;
  582.    long tmpregion;
  583.  
  584.    region_ptr = getf_aregion(&rect[0],&rect[1],
  585.                  &rect[2],&rect[3],&page);
  586.  
  587.    while(region_ptr != rptr && region_ptr)
  588.       region_ptr = getn_aregion(&rect[0],&rect[1],
  589.                     &rect[2],&rect[3],&page);    
  590.  
  591.    while(region_ptr && (region_ptr != stop_ptr))
  592.    {
  593.       if(page == curr_page)
  594.       {
  595.          tmpregion = curregion;
  596.          redraw_area(region_ptr,rect,0);
  597.          curregion = tmpregion;
  598.       }
  599.       region_ptr = getn_aregion(&rect[0],&rect[1],
  600.                           &rect[2],&rect[3],&page);    
  601.  
  602.    }
  603.    do_blit();   
  604. }
  605.  
  606.  
  607. redr_regarea(rptr,bltflag)
  608. register long rptr;
  609. int bltflag;
  610. {
  611.    int rect[4];
  612.    int dummy;
  613.  
  614.    find_boundary(rptr,&rect[0],&rect[1],&rect[2],&rect[3],&dummy,&dummy);
  615.    redraw_area(rptr,rect,bltflag);
  616. }
  617.  
  618. /**************************************************************************/
  619. /* Function:    redraw_area()                          */
  620. /* Description    Redraw loop for polygons, ellipses etc...          */
  621. /**************************************************************************/
  622. redraw_area(rptr,murect,bltflag)
  623.    register REGION *rptr;
  624.    register int murect[];
  625.    int bltflag;
  626. {
  627.    int g_flag;                /* graphic region? */
  628.    int rgrect[4];
  629.    int tgrect[4];
  630.    int rpxy[4];
  631.    int tpxy[4];
  632.    int murec1[4];
  633.    int pts;
  634.  
  635.    int xoffset,yoffset;
  636.  
  637.    if(!rptr)
  638.    {
  639.     pts = 36;
  640.     xoffset = pts * 18;
  641.     yoffset = pts * 16;
  642.    }    
  643.    else
  644.    {
  645.     pts = rptr->grattr[1];
  646.         if(pts && (rptr->grattr[2] & 0x8000))
  647.         {
  648.        xoffset = pts * 18;
  649.        yoffset = pts * 16;
  650.         }
  651.         else
  652.     {
  653.        xoffset = 162; /* offsets are in machine units */
  654.        yoffset = 144; /* an eighth of an inch each way*/
  655.               /* based on 1296 and 1152 mus   */
  656.     }
  657.    }
  658.  
  659.    murect[0] -= xoffset;
  660.    murect[1] -= yoffset;
  661.    murect[2] += xoffset;
  662.    murect[3] += yoffset;
  663.  
  664.  
  665.    GDvq_extnd(mhandle,0,intout,mxres,myres,&page_ptr);
  666.  
  667.    mutopage(murect[0],murect[1],&rpxy[0],&rpxy[1],0);
  668.    mutopage(murect[2],murect[3],&rpxy[2],&rpxy[3],0);
  669. #if NEVER
  670.    rpxy[0] -= 2;        /* With solid fills perimeter is on */
  671.    rpxy[1] -= 2;        /* so when erasing with hollow fill */
  672.    rpxy[2] += 2;        /* we must ......            */
  673.    rpxy[3] += 2;        /* Adjust for perimeter being off   */
  674. #endif
  675.    rpxy[0] = max(0,rpxy[0]);
  676.    rpxy[1] = max(0,rpxy[1]);
  677.    rpxy[2] = min(pagew - 1,rpxy[2]);
  678.    rpxy[3] = min(pageh - 1,rpxy[3]);
  679.  
  680.    vs_clip(mhandle,1,rpxy);
  681.    write_white(mhandle);
  682.    v_bar(mhandle,rpxy);
  683.    write_black(mhandle);
  684.  
  685.    rgrect[0] = rpxy[0];
  686.    rgrect[1] = rpxy[1];
  687.    rgrect[2] = rpxy[2] - rpxy[0] + 1;
  688.    rgrect[3] = rpxy[3] - rpxy[1] + 1;
  689.  
  690.    if(show_grids)    /* moved it here cjg */
  691.     do_grids(1,murect[0],murect[1],murect[2],murect[3]);
  692.  
  693.    display_template(1,rgrect);
  694.    
  695.    region_ptr = get_fregion(curr_page,
  696.     &murec1[0],&murec1[1],
  697.     &murec1[2],&murec1[3],&g_flag);
  698.    while(region_ptr)
  699.    {
  700.         if(murec1[0] >= hpage_size)    /* clip it out */
  701.             goto next;
  702.  
  703.         mutopage(murec1[0],murec1[1],&tpxy[0],&tpxy[1],0);
  704.         mutopage(murec1[2],murec1[3],&tpxy[2],&tpxy[3],0);
  705.     
  706.     tgrect[0] = tpxy[0];
  707.         tgrect[1] = tpxy[1];
  708.         tgrect[2] = tpxy[2] - tpxy[0] + 1;
  709.         tgrect[3] = tpxy[3] - tpxy[1] + 1;
  710.     
  711.     if(rc_intersect(rgrect,tgrect))
  712.     {
  713.        if(g_flag)
  714.                get_grattr(region_ptr,glgrattr);
  715.  
  716.            if(g_flag || !mode_flag)
  717.            {
  718.                opcode = get_fprimitive(region_ptr,&count,&wmode);
  719.                while(opcode != -1)
  720.                {
  721.                    switch(opcode)
  722.                    {
  723.                    case 3:
  724.                    case 4:
  725.                    case 0: redraw_polygon(count,wmode,g_flag);
  726.                                break;
  727.  
  728.                case 1: redraw_ellipse(wmode,g_flag);
  729.                        break;
  730.  
  731.                case 2: graphic_setup();
  732.                          break;
  733.                 }
  734.                     opcode = get_nprimitive(&count,&wmode);
  735.                }
  736.        }
  737.            if(mode_flag && !g_flag)
  738.        {
  739.           if(txtptr = get_txtptr(region_ptr))
  740.               {
  741.               if(*txtptr)
  742.           {
  743.                  open_region(region_ptr);
  744.                      do_clipregout(tgrect[0],tgrect[1],
  745.             tgrect[2] + tgrect[0] - 1,
  746.             tgrect[3] + tgrect[1] - 1);
  747.                   }
  748.           }
  749.            }
  750.     }
  751. next:    region_ptr = get_nregion(&murec1[0],&murec1[1],
  752.                         &murec1[2],&murec1[3],&g_flag);
  753.    }
  754.  
  755.    display_template(2,rgrect);
  756.    do_numbers(rgrect,0);
  757.  
  758.    if(bltflag)
  759.    {
  760.       mclip();
  761.       do_blit();
  762.    }
  763. }
  764.  
  765.  
  766. /**************************************************************************/
  767. /* Function:    redraw_images()                          */
  768. /* Description    Redraw loop for polygons, ellipses etc...          */
  769. /**************************************************************************/
  770. redraw_images()
  771. {
  772.    int endflag;
  773.    int g_flag;                /* graphic region? */
  774.  
  775.    if((!blit_flag) || mode_change)
  776.    {
  777.       clrmem(page_ptr,pagebytes);
  778.  
  779.       if(show_grids)
  780.     do_grids(0,0,0,0,0);
  781.  
  782.         display_template(1,0L);
  783.         region_ptr = get_fregion(curr_page,
  784.             &rect_in_mu[0],&rect_in_mu[1],
  785.             &rect_in_mu[2],&rect_in_mu[3],&g_flag);
  786.         while(region_ptr)
  787.         {
  788.              if(rect_in_mu[0] >= hpage_size)    /* clip it out! */
  789.                 goto next;
  790.  
  791.              mclip();
  792.              if(!g_flag)
  793.                  get_txtattr(region_ptr,&gltxtattr);
  794.          else 
  795.          get_grattr(region_ptr,glgrattr);
  796.          if(g_flag || !mode_flag)
  797.          {
  798.                 opcode = get_fprimitive(region_ptr,&count,&wmode);
  799.                 while(opcode != -1)
  800.                 {
  801.                    switch(opcode)
  802.                    {
  803.                    case 3:
  804.                    case 4:
  805.                    case 0: redraw_polygon(count,wmode,g_flag);
  806.                                break;
  807.  
  808.                case 1: redraw_ellipse(wmode,g_flag);
  809.                        break;
  810.  
  811.                case 2: graphic_setup();
  812.                          break;
  813.                 }
  814.                     opcode = get_nprimitive(&count,&wmode);
  815.                  }
  816.          }
  817.              if(mode_flag && !g_flag)
  818.          {
  819.             if(txtptr = get_txtptr(region_ptr))
  820.                 {
  821.            if(*txtptr)
  822.            {
  823.                  get_buffvars(region_ptr);
  824.              open_region(region_ptr);
  825.                      do_regoutput(txtptr,&endflag);
  826.                      put_buffvars(region_ptr);
  827.            }
  828.                 }
  829.             GDvq_extnd(mhandle,0,intout,mxres,myres,&page_ptr);
  830.              }
  831.  
  832. next:      region_ptr = get_nregion(&rect_in_mu[0],&rect_in_mu[1],
  833.                         &rect_in_mu[2],&rect_in_mu[3],&g_flag);
  834.       }
  835.       mode_change = FALSE;
  836.       display_template(2,0L);
  837.       do_numbers(0L,0);
  838.    }
  839.    do_blit();            /* Either blit now or redraw,then blit*/
  840. }
  841.  
  842. /**************************************************************************/
  843. /* Function:    zoom_setup()                          */
  844. /* Description    Closes/Open Preview Buffer with new sizes          */
  845. /**************************************************************************/
  846. zoom_setup()
  847. {
  848.       opwidth  = pwork.g_w;
  849.       opheight = pwork.g_h;
  850.       mxres    = pagew;
  851.       myres    = pageh;
  852.  
  853.       if((view_size == PSIZE) || (view_size == PADJCNT))
  854.        mxres = ((mxres + 15)/16)*16;
  855.       GDvq_extnd(mhandle,0,intout,mxres,myres,&page_ptr);
  856.       page_MFDB.fd_w = mxres; 
  857.       page_MFDB.fd_h = myres;
  858.       page_MFDB.fd_wdwidth = (mxres + 15)/16;
  859. }
  860.  
  861.  
  862.  
  863. /**************************************************************************/
  864. /* Function:    do_blit()                          */
  865. /* Description:    Blit GRECT from preview buffer to screen          */
  866. /**************************************************************************/
  867. do_blit()
  868. {
  869.         int color[2];
  870.         color[0] = 1;
  871.         color[1] = 0;
  872.         mutopage(page_area.g_x,page_area.g_y,&page.g_x,&page.g_y,1);
  873.         grect_to_array(&page,blit_area);
  874.     gsx_moff();
  875.     vrt_cpyfm(shandle,1,blit_area,&page_MFDB,&location,color);
  876.     if(ruler_flag)
  877.        show_rulers();
  878.         gsx_mon();
  879. }
  880.  
  881. /**************************************************************************/
  882. /* Function:    mclip()                              */
  883. /* Description: set clipping rectangle in preview buffer          */
  884. /**************************************************************************/
  885. mclip()
  886. {
  887.    int pxy[4];
  888.  
  889.    pxy[0] = pxy[1] = 0;  
  890.    pxy[3] = pageh - 1;
  891.  
  892.    if(view_size == PADJCNT)
  893.    {
  894.      pxy[0] = ((curr_page % 2) ? (pagew/2):(0));
  895.      pxy[2] = ((curr_page % 2) ? (pagew - 1) : (pagew/2));
  896.    }
  897.    else
  898.      pxy[2] = pagew - 1;
  899.  
  900.    vs_clip(mhandle,1,pxy);
  901. }
  902.  
  903.  
  904.  
  905. /**************************************************************************/
  906. /* Function:    scan_clip()                              */
  907. /* Description: set clipping rectangle in scan buffer                 */
  908. /**************************************************************************/
  909. scan_clip()
  910. {
  911.    int pxy[4];
  912.   
  913.    pxy[0] = pxy[1] = 0;
  914.    pxy[2] = scan_xres - 1;
  915.    pxy[3] = scan_yres - 1;
  916.    vs_clip(mhandle,1,pxy);
  917. }
  918.  
  919.  
  920.  
  921. /**************************************************************************/
  922. /* Function:    redraw_laser()                          */
  923. /* Description    Redraw loop for polygons, ellipses etc...          */
  924. /*        Redraw Loop for playing back to the laser printer...      */
  925. /**************************************************************************/
  926. redraw_laser(pagenum)
  927. int pagenum;
  928. {
  929.    int status;
  930.    int prev_flag;
  931.    int endflag;
  932.    int g_flag;                    /* graphic region? */
  933.    int temp;
  934.    int tmp_handle;
  935.    int dxres,dyres;
  936.    int pxy[4];
  937.    long buffer;
  938.  
  939.    endflag = 0;
  940.    g_flag  = FALSE;
  941.    prev_flag = mode_flag;
  942.    mode_flag = TRUE;
  943.    temp = sdevm;
  944.    sdevm = 3;                /* Laser printer CS 4/12 */
  945.  
  946.  
  947.    if(pagetype > PLEGAL)
  948.    {
  949.        tmp_handle = phandle;
  950.        phandle = mhandle;
  951.    }
  952.  
  953.    clrmem(pageim,laser_bytes);
  954.  
  955.    display_template(1,0L);
  956.  
  957.        region_ptr = get_fregion(pagenum,
  958.                 &rect_in_mu[0],&rect_in_mu[1],
  959.                 &rect_in_mu[2],&rect_in_mu[3],&g_flag);
  960.        while(region_ptr)
  961.        {
  962.        if(rect_in_mu[0] >= hpage_size)
  963.                 goto next;
  964.  
  965.            if(!g_flag)
  966.                get_txtattr(region_ptr,&gltxtattr);
  967.            else
  968.                get_grattr(region_ptr,glgrattr);
  969.        if(g_flag || !mode_flag)
  970.        {
  971.                opcode = get_fprimitive(region_ptr,&count,&wmode);
  972.                while(opcode != -1)
  973.                {
  974.                   switch(opcode)
  975.                   {
  976.             case 3:
  977.             case 4:
  978.             case 0:  redraw_polygon(count,wmode,g_flag);
  979.                      break;
  980.             case 1:  redraw_ellipse(wmode,g_flag);
  981.                   break;
  982.             case 2:  insert_graphic();
  983.                  break;
  984.                   }
  985.                   opcode = get_nprimitive(&count,&wmode);
  986.                }
  987.        }
  988.            if(!g_flag)
  989.            {
  990.               if(txtptr = get_txtptr(region_ptr))
  991.               {
  992.          if(*txtptr)
  993.          {
  994.                 get_buffvars(region_ptr);
  995.             open_region(region_ptr);
  996.                     do_regoutput(txtptr,&endflag);         
  997.                     put_buffvars(region_ptr);
  998.          }
  999.               }
  1000.        if(pagetype <= PLEGAL)    /* Don't do this if Landscape*/
  1001.                     GDvq_extnd(mhandle,0,intout,mxres,myres,&page_ptr);
  1002.  
  1003.          }                 /* if(graphics && g_flag) etc... */
  1004. next:    region_ptr = get_nregion(&rect_in_mu[0],&rect_in_mu[1],
  1005.                          &rect_in_mu[2],&rect_in_mu[3],&g_flag);
  1006.  
  1007.  
  1008.    }                /* while(region_ptr          */
  1009.    display_template(2,0L);
  1010.    do_numbers(0L,0);
  1011.  
  1012.  
  1013.    if(pagetype > PLEGAL)
  1014.    {
  1015.        phandle = tmp_handle;
  1016.     mutolas(hpage_size,vpage_size,&dxres,&dyres);
  1017.     dxres = ((dxres + 15)/16)*2;
  1018.     dyres = ((dyres + 15)/16)*2;
  1019.         rotate(pageim,daveptr,dxres,dyres,4);
  1020.    }
  1021.  
  1022.    pxy[0] = pxy[1] = 0;
  1023.    pxy[2] = pxres;
  1024.    pxy[3] = pyres;
  1025.    vs_clip(phandle,1,pxy);
  1026.    buffer = 0L;
  1027.    GDv_updwk(phandle,&buffer,1,&status); 
  1028.    v_clrwk(phandle);
  1029.  
  1030.    mode_flag = prev_flag;
  1031.    sdevm = temp;
  1032. }
  1033.  
  1034.  
  1035. /**************************************************************************/
  1036. /* Function:    redraw_tdo()                          */
  1037. /* Description    Redraw loop for polygons, ellipses etc...          */
  1038. /*        Redraw Loop for playing back to the tdo file...       */
  1039. /**************************************************************************/
  1040. redraw_tdo(pagenum,lastp)
  1041. int pagenum;
  1042. int lastp;
  1043. {
  1044.    int prev_flag;
  1045.    int endflag;
  1046.    int g_flag;                    /* graphic region? */
  1047.  
  1048.    endflag = 0;
  1049.    g_flag  = FALSE;
  1050.    prev_flag = mode_flag;
  1051.    mode_flag = TRUE;
  1052.  
  1053.    
  1054.    tdo_template(1);
  1055.  
  1056.        region_ptr = get_fregion(pagenum,
  1057.                 &rect_in_mu[0],&rect_in_mu[1],
  1058.                 &rect_in_mu[2],&rect_in_mu[3],&g_flag);
  1059.        while(region_ptr)
  1060.        {
  1061.        cpabt = 0;                /* CJG 08/26/89 */
  1062.  
  1063.        if(rect_in_mu[0] >= hpage_size)
  1064.                 goto next;
  1065.            if(!g_flag)
  1066.                get_txtattr(region_ptr,&gltxtattr);
  1067.            else
  1068.                get_grattr(region_ptr,glgrattr);
  1069.        if(g_flag)
  1070.        {
  1071.                opcode = get_fprimitive(region_ptr,&count,&wmode);
  1072.                while(opcode != -1)
  1073.                {
  1074.           switch(opcode)
  1075.                   {
  1076.             case 3:
  1077.             case 4:
  1078.             case 0:
  1079.             case 1:
  1080.                     calc_prim(opcode,&TYF_Gx0,&TYF_Gy0,
  1081.                     &TYF_Gx1,&TYF_Gy1,count);
  1082.                  TYF_Gtype = 5;
  1083.                  insGR_TYF(opcode,count,glgrattr);
  1084.                   break;
  1085.             case 2:  TYF_Gfile = (char *)&ptsarray[5];
  1086.                  TYF_Gx0 = ptsarray[0];
  1087.                  TYF_Gy0 = ptsarray[1];
  1088.                  TYF_Gx1 = ptsarray[2];
  1089.                  TYF_Gy1 = ptsarray[3];
  1090.                  switch(ptsarray[4])
  1091.                  {
  1092.                 case 0:
  1093.                    TYF_Gtype = 2;
  1094.                    break;
  1095.                 case 1:
  1096.                    TYF_Gtype = 3;
  1097.                    break;
  1098.                 case 2:
  1099.                    TYF_Gtype = 1;
  1100.                    break;
  1101.                     case 3:
  1102.                    TYF_Gtype = 4;
  1103.                    break;
  1104.                  }
  1105.                  insGR_TYF(opcode,count,glgrattr);
  1106.                  break;
  1107.                   }
  1108.                   opcode = get_nprimitive(&count,&wmode);
  1109.                }
  1110.        }
  1111.            if(!g_flag)
  1112.            {
  1113.               if(txtptr = get_txtptr(region_ptr))
  1114.               {
  1115.          if(*txtptr)
  1116.          {
  1117.                 get_buffvars(region_ptr);
  1118.             open_region(region_ptr);
  1119.                     do_tdoout(txtptr,&endflag);         
  1120.          }
  1121.               }
  1122.          }                 /* if(graphics && g_flag) etc... */
  1123. next:    region_ptr = get_nregion(&rect_in_mu[0],&rect_in_mu[1],
  1124.                          &rect_in_mu[2],&rect_in_mu[3],&g_flag);
  1125.  
  1126.  
  1127.    }                /* while(region_ptr          */
  1128.    tdo_template(2);
  1129.    do_numbers(0L,1);
  1130.    if(pagenum < lastp)
  1131.       newPge_TYF();
  1132.    mode_flag = prev_flag;
  1133. }
  1134.  
  1135. /**************************************************************************/
  1136. /*  Function:  do_update_text()                          */
  1137. /*  Description: update text pointers                      */
  1138. /**************************************************************************/
  1139. do_update_text()
  1140. {
  1141.    int prev_flag;
  1142.    int dflag;
  1143.    char *txtptr;
  1144.    char *endptr;
  1145.    int g_flag;
  1146.    int page;
  1147.  
  1148.    if(deferhj)            /* Don't recalc text if h&j deferred */
  1149.     return;
  1150.  
  1151.    endptr = -1L;
  1152.    prev_flag = mode_flag;
  1153.    mode_flag = TRUE;
  1154.    g_flag = FALSE;
  1155.  
  1156.    region_ptr = getf_aregion(&rect_in_mu[0],&rect_in_mu[1],
  1157.                  &rect_in_mu[2],&rect_in_mu[3],&page);
  1158.  
  1159.    while(region_ptr)
  1160.    {
  1161.       free_scanrects(region_ptr);
  1162.  
  1163.       region_ptr = getn_aregion(&rect_in_mu[0],&rect_in_mu[1],
  1164.                     &rect_in_mu[2],&rect_in_mu[3],&page);    
  1165.    }
  1166.  
  1167.    GDvq_extnd(mhandle,0,intout,scan_xres,scan_yres,&scanptr);
  1168.    scan_clip();
  1169.    txtptr = get_arttxt();
  1170.  
  1171.    region_ptr = getf_aregion(&rect_in_mu[0],&rect_in_mu[1],
  1172.                  &rect_in_mu[2],&rect_in_mu[3],&page);
  1173.    get_abuffvars(curart);
  1174.    CPrewindow(txtptr);        /* 12/14/89*/
  1175.    savecptr = current_char;
  1176.    while(region_ptr)
  1177.    {
  1178.       clrmem(scanptr,scan_bytes);
  1179.       put_txtptr(region_ptr,txtptr);
  1180.       get_txtattr(region_ptr,&gltxtattr);
  1181.  
  1182.       opcode = get_fprimitive(region_ptr,&count,&wmode);
  1183.       while(opcode != -1)
  1184.       {
  1185.          switch(opcode)
  1186.          {
  1187.             case 0:
  1188.                    redraw_polygon(count,wmode,g_flag);
  1189.            break;
  1190.         case 1:
  1191.                    redraw_ellipse(wmode,g_flag);
  1192.            break;
  1193.  
  1194.         case 2:       /* deliberately skip...*/
  1195.         case 3:
  1196.         case 4:
  1197.                break;
  1198.          }
  1199.              opcode = get_nprimitive(&count,&wmode);
  1200.       }
  1201.       if(!g_flag && txtptr)
  1202.       {
  1203.      chk_repel(region_ptr,rect_in_mu);
  1204.          zdevice = SCANNER;
  1205.          SH = vmupix((int)gltxtattr.lnsp);
  1206.      open_region(region_ptr);
  1207.          endptr = do_handjreg(txtptr,&dflag,1,rect_in_mu);
  1208.       } 
  1209.  
  1210.       if(dflag || (endptr == -1L))
  1211.       {
  1212.           CPrewindow(buf_end);
  1213.           put_abuffvars(curart);
  1214.       mode_flag = prev_flag;
  1215.           GDvq_extnd(mhandle,0,intout,mxres,myres,&page_ptr);
  1216.           return;
  1217.       }
  1218.  
  1219.       if(!g_flag && txtptr)
  1220.            txtptr = endptr;
  1221.  
  1222.       region_ptr = getn_aregion(&rect_in_mu[0],&rect_in_mu[1],
  1223.                     &rect_in_mu[2],&rect_in_mu[3],&page);
  1224.    }
  1225.    CPrewindow(buf_end);
  1226.    put_abuffvars(curart);
  1227.    mode_flag = prev_flag;
  1228.    free_repbuffs();
  1229.    GDvq_extnd(mhandle,0,intout,mxres,myres,&page_ptr);
  1230. }
  1231.  
  1232. page_redraw(rptr)
  1233. long rptr;
  1234. {
  1235. long tmp;
  1236.  
  1237.    tmp = get_regart(rptr);
  1238.    if(tmp)                /* If region is linked        */
  1239.    {
  1240.         open_article(tmp);
  1241.         if(deferhj || view_size == PADJCNT)
  1242.         {
  1243.        do_artcleanup(rptr,0);    /* Re h and j but don't redraw */
  1244.        force_preview();        /* redraw entire page           */
  1245.         }
  1246.         else
  1247.        do_artcleanup(rptr,1);    /* Re h and j and re output    */
  1248.    }
  1249.    else
  1250.    {                    /* Just cleanup region area    */
  1251.         if(view_size == PADJCNT)
  1252.     {       
  1253.        force_preview();
  1254.         }
  1255.     else
  1256.        redr_regarea(rptr,1);
  1257.    }
  1258. }
  1259.  
  1260. /**************************************************************************/
  1261. /*  Function:  do_artcleanup()                          */
  1262. /*  Description: update text pointers                            */
  1263. /*             cleanup page if "redraw_flag" flag is true          */
  1264. /**************************************************************************/
  1265. do_artcleanup(rptr,redraw_flag)
  1266. long rptr;        /* First region that needs updating          */
  1267. int redraw_flag;
  1268. {        
  1269.    int prev_flag;
  1270.    int dflag;
  1271.    char *txtptr;
  1272.    char *endptr;
  1273.    int g_flag;
  1274.    int page;
  1275.    int rect_in_mu[4];
  1276.    long dummy;
  1277.    long scantxt;
  1278.    int i;
  1279.    int hj_aborted;
  1280.    REGION *savereg;
  1281.    long save_free_start;
  1282.  
  1283.    if(deferhj)            /* Don't recalc text if h&j deferred */
  1284.     return;
  1285.   
  1286.    graf_mouse(2,&dummy);
  1287.    get_buffvars(rptr);    /* cjg 060789 */
  1288.    save_free_start = (long)free_start;
  1289.    prev_flag = mode_flag;
  1290.    mode_flag = TRUE;
  1291.    hj_aborted = g_flag = FALSE;
  1292.    endptr = -1L;
  1293.  
  1294. /*
  1295.    region_ptr = getf_aregion(&rect_in_mu[0],&rect_in_mu[1],
  1296.                  &rect_in_mu[2],&rect_in_mu[3],&page);
  1297.  
  1298.    while(region_ptr != rptr && region_ptr)
  1299.    {
  1300.       region_ptr = getn_aregion(&rect_in_mu[0],&rect_in_mu[1],
  1301.                     &rect_in_mu[2],&rect_in_mu[3],&page);    
  1302.    }
  1303.  
  1304.    while(region_ptr)
  1305.    {
  1306.       free_scanrects(region_ptr);
  1307.       region_ptr = getn_aregion(&rect_in_mu[0],&rect_in_mu[1],
  1308.                     &rect_in_mu[2],&rect_in_mu[3],&page);    
  1309.    }
  1310. Add a region, article doesn't flow into last region, but slave code
  1311. remains for this region, therefore we must erase all of the slave 
  1312. code for all regions
  1313. ********** Delete for now */
  1314.    GDvq_extnd(mhandle,0,intout,scan_xres,scan_yres,&scanptr);
  1315.    scan_clip();
  1316.    txtptr = get_arttxt();
  1317.    region_ptr = getf_aregion(&rect_in_mu[0],&rect_in_mu[1],
  1318.                  &rect_in_mu[2],&rect_in_mu[3],&page);
  1319.  
  1320.    while(region_ptr != rptr && region_ptr)
  1321.    {
  1322.       region_ptr = getn_aregion(&rect_in_mu[0],&rect_in_mu[1],
  1323.                     &rect_in_mu[2],&rect_in_mu[3],&page);    
  1324.       txtptr = get_txtptr(region_ptr);
  1325.    }
  1326.    get_abuffvars(curart);
  1327.    CPrewindow(txtptr);        /* 12/14/89*/
  1328.    savecptr = current_char;
  1329.    while(region_ptr)
  1330.    {
  1331.       free_scanrects(region_ptr);
  1332.       clrmem(scanptr,scan_bytes);
  1333.       put_txtptr(region_ptr,txtptr);
  1334.       get_txtattr(region_ptr,&gltxtattr);
  1335.  
  1336.       opcode = get_fprimitive(region_ptr,&count,&wmode);
  1337.       while(opcode != -1)
  1338.       {
  1339.          switch(opcode)
  1340.          {
  1341.             case 0:
  1342.                    redraw_polygon(count,wmode,g_flag);
  1343.            break;
  1344.         case 1:
  1345.                    redraw_ellipse(wmode,g_flag);
  1346.            break;
  1347.  
  1348.         case 2:       /* deliberately skip...*/
  1349.         case 3:
  1350.         case 4:
  1351.                break;
  1352.          }
  1353.              opcode = get_nprimitive(&count,&wmode);
  1354.       }
  1355.       if(!g_flag && txtptr && *txtptr)
  1356.       {
  1357.      chk_repel(region_ptr,rect_in_mu);
  1358.          zdevice = SCANNER;
  1359.          SH = vmupix((int)gltxtattr.lnsp);
  1360.      open_region(region_ptr);
  1361.          endptr = do_handjreg(txtptr,&dflag,1,rect_in_mu);
  1362.       } 
  1363.  
  1364.       if(dflag || (endptr == -1L))
  1365.       {
  1366.           CPrewindow(buf_end);
  1367.           put_abuffvars(curart);
  1368.  
  1369.           region_ptr = getn_aregion(&rect_in_mu[0],&rect_in_mu[1],
  1370.                     &rect_in_mu[2],&rect_in_mu[3],&page);    
  1371.           while(region_ptr)
  1372.           {
  1373.              free_scanrects(region_ptr);
  1374.              region_ptr = getn_aregion(&rect_in_mu[0],&rect_in_mu[1],
  1375.                     &rect_in_mu[2],&rect_in_mu[3],&page);    
  1376.           }
  1377.       mode_flag = prev_flag;
  1378.           GDvq_extnd(mhandle,0,intout,mxres,myres,&page_ptr);
  1379.       make_slave(rptr,0L);
  1380.       if(redraw_flag)
  1381.          page_cleanup(rptr,0L);
  1382.           graf_mouse(ARROW,&dummy);
  1383.           return;
  1384.       }
  1385.  
  1386.       if(!g_flag && txtptr)
  1387.            txtptr = endptr;
  1388.  
  1389.       region_ptr = getn_aregion(&rect_in_mu[0],&rect_in_mu[1],
  1390.                     &rect_in_mu[2],&rect_in_mu[3],&page);
  1391.       if(region_ptr)
  1392.       {
  1393.          getf_scaninfo(region_ptr,&i,&i,&i,&i,&scantxt,&dummy);
  1394.          if(save_free_start - scantxt == buf_end - savecptr)
  1395.      {
  1396.         savereg = region_ptr;
  1397.         hj_aborted = 1;
  1398.         region_ptr = 0L;          /* Text matches up              */
  1399.      }
  1400.       }
  1401.    }
  1402.    CPrewindow(buf_end);
  1403.    if(hj_aborted)
  1404.    {
  1405.       adjust_txtptrs(savereg,endptr);
  1406.    }
  1407.    put_abuffvars(curart);
  1408.    mode_flag = prev_flag;
  1409.    free_repbuffs();
  1410.    GDvq_extnd(mhandle,0,intout,mxres,myres,&page_ptr);
  1411.    if(hj_aborted)
  1412.         make_slave(rptr,savereg);
  1413.    else
  1414.          make_slave(rptr,0L);
  1415.  
  1416.    if(redraw_flag)
  1417.    {
  1418.       if(hj_aborted)
  1419.         page_cleanup(rptr,savereg);
  1420.       else
  1421.               page_cleanup(rptr,0L);
  1422.    }
  1423.    graf_mouse(ARROW,&dummy);
  1424. }
  1425.  
  1426.  
  1427. adjust_txtptrs(rptr,txtptr)
  1428. REGION *rptr;
  1429. char *txtptr;
  1430. {
  1431.    int dummy;
  1432.    long ldummy;
  1433.    SCANINFO *rscan;
  1434.    while(rptr)
  1435.    {
  1436.       rscan = getf_scaninfo(rptr,&dummy,&dummy,&dummy,&dummy,&ldummy,&ldummy);
  1437.       rptr->txtstart = txtptr;
  1438.       while(rscan)
  1439.       {
  1440.          rscan->textptr = txtptr;
  1441.          while(txtptr <= free_start)
  1442.      {
  1443.         if(  *txtptr == 0x0A && 
  1444.         (*(txtptr - 2) == 0x0C || 
  1445.          *(txtptr - 2) == 0x1F || 
  1446.          *(txtptr - 2) == 0x0F))
  1447.              {
  1448.                 txtptr++;        /* Read past the line feed */
  1449.             break;
  1450.          }
  1451.          else
  1452.                     txtptr++;
  1453.      }
  1454.          if(txtptr >= free_start)
  1455.          return;
  1456.          rscan = getn_scaninfo(&dummy,&dummy,&dummy,&dummy,&ldummy,&ldummy);
  1457.       }
  1458.       rptr = rptr->alink;
  1459.    }
  1460. }
  1461.          
  1462. /**************************************************************************/
  1463. /*  Function:   graphic_setup()                          */
  1464. /*  Description: if "image_status" == 0, draw with filled Atari Logos      */
  1465. /*         else draw the actual image.                  */
  1466. /**************************************************************************/
  1467. graphic_setup()
  1468. {
  1469.    if(!image_status)
  1470.    {
  1471.       ptsarray[4] = ptsarray[2];
  1472.       ptsarray[5] = ptsarray[3];
  1473.          
  1474.       ptsarray[2] = ptsarray[0];
  1475.       ptsarray[3] = ptsarray[5];
  1476.  
  1477.       ptsarray[6] = ptsarray[4];
  1478.       ptsarray[7] = ptsarray[1];
  1479.       cur_primitive = OIMAGE;
  1480.       redraw_polygon(4,wmode,1);
  1481.       cur_primitive = 0;
  1482.    }
  1483.    else insert_graphic();
  1484. }
  1485.  
  1486.  
  1487.  
  1488. /**************************************************************************/
  1489. /*  Function:   force_preview()                          */
  1490. /*  Description: Forces a redraw on the preview window...          */
  1491. /**************************************************************************/
  1492. force_preview()
  1493. {
  1494.      force_draw_flag = TRUE;
  1495.      msg_buff[0] = msg_buff[1] = msg_buff[2] = 0;
  1496.      msg_buff[3] = prev_handle;
  1497.      msg_buff[4] = pwork.g_x;
  1498.      msg_buff[5] = pwork.g_y;
  1499.      msg_buff[6] = pwork.g_w;
  1500.      msg_buff[7] = pwork.g_h;
  1501.      do_redraw(msg_buff);
  1502. }
  1503.  
  1504.  
  1505.  
  1506. /**************************************************************************/
  1507. /* Function: force_blit_redraw()                      */
  1508. /* Description: Another force redraw message                  */
  1509. /**************************************************************************/
  1510. force_blit_redraw(noprev)
  1511. int noprev;
  1512. {
  1513.      if(!noprev)
  1514.      {
  1515.         msg_buff[0] = msg_buff[1] = msg_buff[2] = 0;
  1516.         msg_buff[3] = prev_handle;
  1517.         msg_buff[4] = pwork.g_x;
  1518.         msg_buff[5] = pwork.g_y;
  1519.         msg_buff[6] = pwork.g_w;
  1520.         msg_buff[7] = pwork.g_h;
  1521.         do_redraw(msg_buff);
  1522.      }
  1523. }
  1524.  
  1525.  
  1526. /**************************************************************************/
  1527. /* Function:  recalc_txtptrs()                          */
  1528. /* Description: Adjusts the vgtext to break on consistent boundaries.     */
  1529. /**************************************************************************/
  1530. recalc_txtptrs()
  1531. {
  1532.     register unsigned long txtptr;
  1533.     int dummy;
  1534.  
  1535.     if(deferhj)            /* Defer h&j so don't recalc text ptrs */
  1536.     return;
  1537.     graf_mouse(2,&dummy);
  1538.     txtptr = getf_article();
  1539.     while(txtptr)
  1540.     {
  1541.          do_update_text();
  1542.          txtptr = getn_article();
  1543.     }
  1544.     graf_mouse(ARROW,&dummy);
  1545. }
  1546.  
  1547.  
  1548.  
  1549.  
  1550. /**************************************************************************/
  1551. /* Function: recalc_rtext()                          */
  1552. /* Description: Only recalc 1 articles region textptrs              */
  1553. /**************************************************************************/
  1554. recalc_rtext()
  1555. {
  1556.    int dummy;
  1557.    long tempart;
  1558.  
  1559.    if(deferhj)
  1560.     return;
  1561.    graf_mouse(2,&dummy);
  1562.    tempart = get_regart(gl_region_ptr);
  1563.    if(tempart)
  1564.    {
  1565.       open_article(tempart);
  1566.       do_update_text();
  1567.    }
  1568.    graf_mouse(ARROW,&dummy);
  1569. }
  1570.  
  1571.  
  1572.  
  1573.  
  1574. /**************************************************************************/
  1575. /* Function: clear_preview()                          */
  1576. /* Description: Clear preview window                      */
  1577. /**************************************************************************/
  1578. clear_preview()
  1579. {
  1580. /*    gsx_moff();*/
  1581.     vsf_interior(shandle,2);
  1582.     vsf_style(shandle,1);
  1583.     vsf_perimeter(shandle,0);
  1584.  
  1585.     vr_recfl(shandle,aclear);
  1586.     vr_recfl(shandle,aclear2);
  1587. /*    gsx_mon();*/
  1588. }
  1589.  
  1590.  
  1591.  
  1592. /**************************************************************************/
  1593. /* Function: update_preview_blit()                      */
  1594. /* Description: update blit rectangles...                  */
  1595. /**************************************************************************/
  1596. update_preview_blit()
  1597. {
  1598.     blit_area[4] = dpwork.g_x;
  1599.     blit_area[5] = dpwork.g_y;
  1600.     blit_area[6] = dpwork.g_x + dpwork.g_w - 1;
  1601.     blit_area[7] = dpwork.g_y + dpwork.g_h - 1;
  1602.     mutopage(page_area.g_w,page_area.g_h,&page.g_w,&page.g_h,1);
  1603. }
  1604.  
  1605.  
  1606.  
  1607.  
  1608.  
  1609. /**************************************************************************/
  1610. /* Function: init_rulers()                          */
  1611. /* Description: initialize h and v rulers                  */
  1612. /**************************************************************************/
  1613. init_rulers()
  1614. {
  1615.    int pxy[4];
  1616.  
  1617.    vsf_interior(rule_handle,0);
  1618.    vswr_mode(rule_handle,1);
  1619.    
  1620.    vsl_width(mhandle,1);        /* set line width to 1          */
  1621.    vsl_type(mhandle,1);            /* set line type to solid      */
  1622.    vsl_ends(mhandle,0,0);         /* restore end styles          */
  1623.    
  1624.    pxy[0] = pwork.g_x;
  1625.    pxy[1] = pwork.g_y;
  1626.    pxy[2] = dpwork.g_x;
  1627.    pxy[3] = dpwork.g_y;
  1628.    vr_recfl(rule_handle,pxy);
  1629.  
  1630.    vswr_mode(rule_handle,3);
  1631.  
  1632.    if(view_size == P200)
  1633.    {
  1634.     mutopage(324,288,&hhalf,&vhalf,1);
  1635.     mutopage(41,36,&hlen,&vlen,1);
  1636.    }
  1637.    else
  1638.    {
  1639.         mutopage(648,576,&hhalf,&vhalf,1);
  1640.         mutopage(81,72,&hlen,&vlen,1);        /* Ruler length 1/16 incs    */
  1641.    }
  1642.  
  1643.    
  1644.    x_eighths = 162;
  1645.    y_eighths = 144;
  1646.   
  1647.    if(hrbuffer)
  1648.    {
  1649.       free(hrbuffer);
  1650.    }
  1651.    if(vrbuffer)
  1652.    {
  1653.       free(vrbuffer);
  1654.    }
  1655.    hrbuffer = (int *)get_lcmem((long)(vhalf*(((mxres+7)/8)+1)));
  1656.    vrbuffer = (int *)get_lcmem((long)(myres * (((hhalf+7)/8)+1)));
  1657.    if(hrbuffer && vrbuffer)
  1658.    {
  1659.       ruler_hasmem = 1;
  1660.       init_hrulers();
  1661.       init_vrulers();
  1662.       GDvq_extnd(mhandle,0,intout,mxres,myres,&page_ptr);
  1663.    }
  1664.    else
  1665.    {
  1666.       alert_cntre(ALERT30);
  1667.       ruler_hasmem = 0;
  1668.    }
  1669.    xold_mark = -1;                /* Init ruler marks */
  1670.    yold_mark = -1;   
  1671.  
  1672. }
  1673.  
  1674.  
  1675.  
  1676.  
  1677.  
  1678. /**************************************************************************/
  1679. /* Function: init_hrulers()                          */
  1680. /* Description: initialize horizontal rulers                  */
  1681. /**************************************************************************/
  1682. init_hrulers()
  1683. {
  1684.    int pxy[4];
  1685.    int dummy;
  1686.  
  1687.    GDvq_extnd(mhandle,0,intout,mxres,vhalf,&hrbuffer);
  1688.    vst_alignment(mhandle,1,5,&dummy,&dummy);
  1689.    hrule_mfdb.fd_addr = hrbuffer;
  1690.    hrule_mfdb.fd_w    = mxres;
  1691.    hrule_mfdb.fd_h    = vhalf;
  1692.    hrule_mfdb.fd_wdwidth = (mxres + 15)/16;
  1693.    hrule_mfdb.fd_stand = 0;
  1694.    hrule_mfdb.fd_nplanes = 1;
  1695.  
  1696.    pxy[0] = 0;
  1697.    pxy[1] = 0;
  1698.    pxy[2] = mxres - 1;
  1699.    pxy[3] = vhalf - 1;
  1700.    vs_clip(mhandle,1,pxy);
  1701.  
  1702.    pxy[0] = 0;
  1703.    pxy[1] = vhalf - 1;
  1704.    pxy[2] = mxres;
  1705.    pxy[3] = vhalf - 1;
  1706.    v_pline(mhandle,2,pxy);
  1707.  
  1708.    switch(unit_type)
  1709.    {
  1710.       case 0:
  1711.         init_hinches();
  1712.         break;
  1713.  
  1714.     case 1:
  1715.         init_hpicas();
  1716.         break;
  1717.  
  1718.     case 2:
  1719.         init_hcents();
  1720.         break;
  1721.  
  1722.     case 3: init_hciceros();
  1723.         break;
  1724.    }
  1725. }
  1726.  
  1727.  
  1728.  
  1729.  
  1730. /**************************************************************************/
  1731. /* Function: init_vrulers()                          */
  1732. /* Description: Initialize vertical rulers                  */
  1733. /**************************************************************************/
  1734. init_vrulers()
  1735. {
  1736.    int pxy[4];
  1737.    int dummy;
  1738.  
  1739.    GDvq_extnd(mhandle,0,intout,hhalf,myres,&vrbuffer);
  1740.    vst_alignment(mhandle,1,1,&dummy,&dummy);
  1741.    vrule_mfdb.fd_addr = vrbuffer;
  1742.    vrule_mfdb.fd_w    = hhalf;
  1743.    vrule_mfdb.fd_h    = myres;
  1744.    vrule_mfdb.fd_wdwidth = (hhalf + 15)/16;
  1745.    vrule_mfdb.fd_stand = 0;
  1746.    vrule_mfdb.fd_nplanes = 1;
  1747.  
  1748.    pxy[0] = 0;
  1749.    pxy[1] = 0;
  1750.    pxy[2] = hhalf - 1;
  1751.    pxy[3] = myres - 1;
  1752.    vs_clip(mhandle,1,pxy);
  1753.  
  1754.  
  1755.    pxy[0] = hhalf - 1;
  1756.    pxy[1] = 0;
  1757.    pxy[2] = hhalf - 1;
  1758.    pxy[3] = myres - 1;
  1759.    v_pline(mhandle,2,pxy);
  1760.  
  1761.    switch(unit_type)
  1762.    {
  1763.       case 0:
  1764.         init_vinches();
  1765.         break;
  1766.  
  1767.     case 1:
  1768.         init_vpicas();
  1769.         break;
  1770.  
  1771.     case 2:
  1772.         init_vcents();
  1773.         break;
  1774.  
  1775.     case 3: init_vciceros();
  1776.         break;
  1777.    }
  1778. }
  1779.  
  1780.  
  1781.  
  1782.  
  1783. /**************************************************************************/
  1784. /* Function: init_hinches()                          */
  1785. /* Description: Initialize h-ruler to inches                  */
  1786. /**************************************************************************/
  1787. init_hinches()
  1788. {
  1789.    int hpos;
  1790.    int vpos;
  1791.    int pxy[4];
  1792.    register int i;
  1793.    register int xmu_pos;
  1794.    register int len;
  1795.    char str[3];
  1796.  
  1797.    i = 1;
  1798.    xmu_pos = x_eighths;
  1799.    mutopage(xmu_pos,0,&hpos,&vpos,1);
  1800.  
  1801.    while(hpos < pagew)
  1802.    {
  1803.         hpos ++;
  1804.     len = vlen;
  1805.     if(!(i%2))
  1806.        len += vlen;
  1807.     if(!(i%4))
  1808.        len += vlen;
  1809.     if(!(i%8))
  1810.        {
  1811.        len += vlen;
  1812.        if((view_size != PSIZE) &&
  1813.           (view_size != PADJCNT) && mnumfnt)
  1814.        {
  1815.           itoa(i/8,str);
  1816.           v_gtext(mhandle,hpos+2*hlen,2*vlen,str);
  1817.        }
  1818.     }
  1819.  
  1820.     pxy[0] = pxy[2] = hpos;
  1821.     pxy[1] = vhalf - 1;
  1822.     pxy[3] = pxy[1] - len;
  1823.     v_pline(mhandle,2,pxy);
  1824.     xmu_pos += x_eighths;            /* Add an eighth to hpos */
  1825.     mutopage(xmu_pos,0,&hpos,&vpos,1);
  1826.         i++;
  1827.    }
  1828.  
  1829. }
  1830.  
  1831.  
  1832.  
  1833.  
  1834.  
  1835. /**************************************************************************/
  1836. /* Function: init_hpicas()                          */
  1837. /* Description: Initialize h-ruler to picas                  */
  1838. /**************************************************************************/
  1839. init_hpicas()
  1840. {
  1841.    int hpos;
  1842.    int vpos;
  1843.    int pxy[4];
  1844.    register int i;
  1845.    register int len;
  1846.    register int xmu_pos;
  1847.    char str[3];
  1848.  
  1849.    i = 1;
  1850.    xmu_pos = 216;            /* mu's per pica    */
  1851.    mutopage(xmu_pos,0,&hpos,&vpos,1);
  1852.    while(hpos < pagew)
  1853.    {
  1854.     hpos++;
  1855.         len = vlen;
  1856.     if(!(i%10))
  1857.     {
  1858.        len += vlen;
  1859.        if( (view_size != PSIZE) && (view_size != PADJCNT) && mnumfnt)
  1860.        {
  1861.           itoa(i,str);
  1862.           v_gtext(mhandle,hpos+2*hlen,2*vlen,str);
  1863.        }
  1864.         }
  1865.     pxy[0] = pxy[2] = hpos;
  1866.     pxy[1] = vhalf - 1;
  1867.     pxy[3] = pxy[1] - len;
  1868.     v_pline(mhandle,2,pxy);
  1869.     xmu_pos += 216;
  1870.     mutopage(xmu_pos,0,&hpos,&vpos,1);
  1871.         i++;
  1872.    }
  1873.  
  1874. }
  1875.  
  1876.  
  1877.  
  1878.  
  1879.  
  1880. /**************************************************************************/
  1881. /* Function: init_hcents()                          */
  1882. /* Description: Initialize h-ruler to centimeters              */
  1883. /**************************************************************************/
  1884. init_hcents()
  1885. {
  1886.    int hpos,vpos;
  1887.    int pxy[4];
  1888.    register int i;
  1889.    register int xmu_pos;
  1890.    register int len;
  1891.    char str[3];
  1892.    int centi_pos;
  1893.  
  1894.    i = 1;
  1895.    centi_pos = 0;        /* Avoid propagating error       */
  1896.    xmu_pos = 51;                /* Mu's/millimeter */
  1897.    mutopage(xmu_pos,0,&hpos,&vpos,1);
  1898.    while(hpos < pagew)
  1899.    {
  1900.     hpos++;
  1901.     len = vlen;
  1902.     if(!(i%10))
  1903.        {
  1904.        len += vlen;
  1905.        if((view_size != PSIZE) &&
  1906.           (view_size != PADJCNT) && mnumfnt)
  1907.        {
  1908.           itoa(i/10,str);
  1909.           v_gtext(mhandle,hpos+2*hlen,2*vlen,str);
  1910.        }
  1911.        centi_pos += 510;
  1912.        xmu_pos = centi_pos;        /* re-calibrate spacing */
  1913.     }
  1914.  
  1915.     pxy[0] = pxy[2] = hpos;
  1916.     pxy[1] = vhalf - 1;
  1917.     pxy[3] = pxy[1] - len;
  1918.     v_pline(mhandle,2,pxy);
  1919.     xmu_pos += 51;
  1920.     mutopage(xmu_pos,0,&hpos,&vpos,1);
  1921.         i++;
  1922.    }
  1923.  
  1924. }
  1925.  
  1926.  
  1927.  
  1928. /**************************************************************************/
  1929. /* Function: init_hciceros()                          */
  1930. /* Description: Initialize h-ruler to ciceros                  */
  1931. /**************************************************************************/
  1932. init_hciceros()
  1933. {
  1934.    int hpos;
  1935.    int vpos;
  1936.    int pxy[4];
  1937.    register int i;
  1938.    register int len;
  1939.    register int xmu_pos;
  1940.    char str[3];
  1941.  
  1942.    i = 1;
  1943.    xmu_pos = 231;            /* mu's per cicero    */
  1944.    mutopage(xmu_pos,0,&hpos,&vpos,1);
  1945.    while(hpos < pagew)
  1946.    {
  1947.     hpos++;
  1948.         len = vlen;
  1949.     if(!(i%10))
  1950.     {
  1951.        len += vlen;
  1952.        if( (view_size != PSIZE) && (view_size != PADJCNT) && mnumfnt)
  1953.        {
  1954.           itoa(i,str);
  1955.           v_gtext(mhandle,hpos+2*hlen,2*vlen,str);
  1956.        }
  1957.         }
  1958.     pxy[0] = pxy[2] = hpos;
  1959.     pxy[1] = vhalf - 1;
  1960.     pxy[3] = pxy[1] - len;
  1961.     v_pline(mhandle,2,pxy);
  1962.     xmu_pos += 231;
  1963.     mutopage(xmu_pos,0,&hpos,&vpos,1);
  1964.         i++;
  1965.    }
  1966. }
  1967.  
  1968.  
  1969.  
  1970. /**************************************************************************/
  1971. /* Function: init_vinches()                          */
  1972. /* Description: initialize v-ruler to inches                  */
  1973. /**************************************************************************/
  1974. init_vinches()
  1975. {
  1976.    int hpos;
  1977.    int vpos;
  1978.    int pxy[4];
  1979.    register int i;
  1980.    register int ymu_pos;
  1981.    int len;
  1982.    char str[3];
  1983.  
  1984.    i = 1;
  1985.    ymu_pos = y_eighths;
  1986.    mutopage(0,ymu_pos,&hpos,&vpos,1);
  1987.    while(vpos < pageh)
  1988.    {
  1989.     len = hlen;
  1990.     if(!(i%2))
  1991.        len += hlen;
  1992.     if(!(i%4))
  1993.        len += hlen;
  1994.     if(!(i%8))
  1995.        {
  1996.        len += hlen;
  1997.        if((view_size != PSIZE) &&
  1998.           (view_size != PADJCNT) && mnumfnt)
  1999.        {
  2000.           itoa(i/8,str);
  2001.           v_gtext(mhandle,3*hlen,vpos+vlen,str);
  2002.        }
  2003.     }
  2004.  
  2005.     pxy[0] = hhalf - 1;
  2006.     pxy[1] = pxy[3] = vpos;
  2007.     pxy[2] = pxy[0] - len;
  2008.     v_pline(mhandle,2,pxy);
  2009.     ymu_pos += y_eighths;            /* Add an eighth to hpos */
  2010.     mutopage(0,ymu_pos,&hpos,&vpos,1);
  2011.         i++;
  2012.    }
  2013.  
  2014. }
  2015.  
  2016.  
  2017.  
  2018.  
  2019. /**************************************************************************/
  2020. /* Function: init_vpicas()                          */
  2021. /* Description: Initialize v-ruler to picas                  */
  2022. /**************************************************************************/
  2023. init_vpicas()
  2024. {
  2025.    int hpos;
  2026.    int vpos;
  2027.    int pxy[4];
  2028.    register int i;
  2029.    register int ymu_pos;
  2030.    register int len;
  2031.    char str[3];
  2032.  
  2033.    i = 1;
  2034.    ymu_pos = 192;
  2035.    mutopage(0,ymu_pos,&hpos,&vpos,1);
  2036.    while(vpos < pageh)
  2037.    {
  2038.         len = hlen;
  2039.     if(!(i%10))
  2040.     {
  2041.        len += hlen;
  2042.        if((view_size != PSIZE) &&
  2043.           (view_size != PADJCNT) && mnumfnt)
  2044.        {
  2045.           itoa(i,str);
  2046.           v_gtext(mhandle,3*hlen,vpos+vlen,str);
  2047.        }
  2048.     }
  2049.     pxy[0] = hhalf - 1;
  2050.     pxy[1] = pxy[3] = vpos;
  2051.     pxy[2] = pxy[0] - len;
  2052.     v_pline(mhandle,2,pxy);
  2053.     ymu_pos += 192;
  2054.     mutopage(0,ymu_pos,&hpos,&vpos,1);
  2055.         i++;
  2056.    }
  2057. }
  2058.  
  2059.  
  2060.  
  2061.  
  2062. /**************************************************************************/
  2063. /* Function: init_vcents()                          */
  2064. /* Description: Initialize v-ruler to centimeters              */
  2065. /**************************************************************************/
  2066. init_vcents()
  2067. {
  2068.    int hpos;
  2069.    int vpos;
  2070.    int pxy[4];
  2071.    register int i;
  2072.    register int ymu_pos;
  2073.    register int len;
  2074.    char str[3];
  2075.    int centi_pos;
  2076.  
  2077.    i = 1;
  2078.    centi_pos = 0;
  2079.    ymu_pos = 45;
  2080.    mutopage(0,ymu_pos,&hpos,&vpos,1);
  2081.    while(vpos < pageh)
  2082.    {
  2083.     len = hlen;
  2084.     if(!(i%10))
  2085.        {
  2086.        len += hlen;
  2087.        if((view_size != PSIZE) &&
  2088.           (view_size != PADJCNT) && mnumfnt)
  2089.        {
  2090.           itoa(i/10,str);
  2091.           v_gtext(mhandle,3*hlen,vlen+vpos,str);
  2092.        }
  2093.        centi_pos += 454;
  2094.        ymu_pos = centi_pos;
  2095.     }
  2096.  
  2097.     pxy[0] = hhalf - 1;
  2098.     pxy[1] = pxy[3] = vpos;
  2099.     pxy[2] = pxy[0] - len;
  2100.     v_pline(mhandle,2,pxy);
  2101.     ymu_pos += 45;   
  2102.     mutopage(0,ymu_pos,&hpos,&vpos,1);
  2103.         i++;
  2104.    }
  2105.  
  2106. }
  2107.  
  2108.  
  2109.  
  2110.  
  2111. /**************************************************************************/
  2112. /* Function: init_vciceros()                          */
  2113. /* Description: Initialize v-ruler to ciceros                  */
  2114. /**************************************************************************/
  2115. init_vciceros()
  2116. {
  2117.    int hpos;
  2118.    int vpos;
  2119.    int pxy[4];
  2120.    register int i;
  2121.    register int ymu_pos;
  2122.    register int len;
  2123.    char str[3];
  2124.  
  2125.    i = 1;
  2126.    ymu_pos = 205;
  2127.    mutopage(0,ymu_pos,&hpos,&vpos,1);
  2128.    while(vpos < pageh)
  2129.    {
  2130.         len = hlen;
  2131.     if(!(i%10))
  2132.     {
  2133.        len += hlen;
  2134.        if((view_size != PSIZE) &&
  2135.           (view_size != PADJCNT) && mnumfnt)
  2136.        {
  2137.           itoa(i,str);
  2138.           v_gtext(mhandle,3*hlen,vpos+vlen,str);
  2139.        }
  2140.     }
  2141.     pxy[0] = hhalf - 1;
  2142.     pxy[1] = pxy[3] = vpos;
  2143.     pxy[2] = pxy[0] - len;
  2144.     v_pline(mhandle,2,pxy);
  2145.     ymu_pos += 205;
  2146.     mutopage(0,ymu_pos,&hpos,&vpos,1);
  2147.         i++;
  2148.    }
  2149. }
  2150.  
  2151.  
  2152.  
  2153. /**************************************************************************/
  2154. /* Function: show_rulers()                          */
  2155. /* Description: Handle the display of rulers                  */
  2156. /**************************************************************************/   
  2157. show_rulers()
  2158. {
  2159. int pxy[8];
  2160. long scrn_mfdb;
  2161. int xoffset,yoffset;
  2162. int dummy;
  2163. int color_index[2];
  2164.  
  2165.  
  2166.    color_index[0] = 1;
  2167.    color_index[1] = 0;
  2168.    scrn_mfdb = 0L;
  2169.    mutopage(page_area.g_x,page_area.g_y,&xoffset,&yoffset,1);
  2170.    vsf_interior(shandle,0);
  2171.  
  2172.    pxy[0] = xoffset;
  2173.    pxy[1] = 0;
  2174.    pxy[2] = pxy[0] + dpwork.g_w - 1;
  2175.    pxy[3] = vhalf - 1;
  2176.    pxy[4] = pwork.g_x + hhalf - 1;
  2177.    pxy[5] = pwork.g_y;
  2178.    pxy[6] = pxy[4] + dpwork.g_w - 1;
  2179.    pxy[7] = pxy[5] + vhalf - 1;
  2180.    if(ruler_hasmem)
  2181.       vrt_cpyfm(rule_handle,1,pxy,&hrule_mfdb,&scrn_mfdb,color_index);
  2182.    else
  2183.       vr_recfl(shandle,&pxy[4]);        /* Don't draw in xor */
  2184.    pxy[0] = 0;
  2185.    pxy[1] = yoffset;
  2186.    pxy[2] = hhalf - 1;
  2187.    pxy[3] = pxy[1] + dpwork.g_h - 1;
  2188.    pxy[4] = pwork.g_x;
  2189.    pxy[5] = dpwork.g_y;
  2190.    pxy[6] = pxy[4] + hhalf - 1;
  2191.    pxy[7] = pxy[5] + dpwork.g_h - 1;
  2192.    if(ruler_hasmem)
  2193.       vrt_cpyfm(rule_handle,1,pxy,&vrule_mfdb,&scrn_mfdb,color_index);
  2194.    else
  2195.       vr_recfl(shandle,&pxy[4]);
  2196.    pxy[0] = pwork.g_x;
  2197.    pxy[1] = pwork.g_y;
  2198.    pxy[2] = dpwork.g_x;
  2199.    pxy[3] = dpwork.g_y;
  2200.    vr_recfl(shandle,pxy);        /* Don't draw in xor */
  2201.  
  2202.    pxy[0] = dpwork.g_x;
  2203.    pxy[1] = pwork.g_y;
  2204.    pxy[2] = dpwork.g_x;
  2205.    pxy[3] = dpwork.g_y;
  2206.    pxy[4] = pwork.g_x;
  2207.    pxy[5] = dpwork.g_y;
  2208.    v_pline(rule_handle,3,pxy);
  2209.  
  2210.    graf_mkstate(&newx,&newy,&dummy,&dummy);
  2211.    xold_mark = -1;
  2212.    yold_mark = -1;
  2213.    do_rule_mark();
  2214. }
  2215.  
  2216.  
  2217.  
  2218.  
  2219. /**************************************************************************/
  2220. /* Function: do_grids()                              */
  2221. /* Description: Display grids on screen                      */
  2222. /**************************************************************************/
  2223. do_grids(clip,x1,y1,x2,y2)
  2224. int clip;
  2225. register int x1;
  2226. int y1;
  2227. register int x2;
  2228. int y2;
  2229. {
  2230.  
  2231.    int xpos,ypos;
  2232.    register int hmus,vmus;
  2233.    int bytes_line;
  2234.  
  2235.    bytes_line = (mxres + 7)/8;
  2236.    bytes_line = (bytes_line + 1) & 0xFFFE;
  2237.  
  2238.    if(clip)
  2239.    {
  2240.     x1 -= hgridspace;
  2241.     x2 += hgridspace;
  2242.     y1 -= vgridspace;
  2243.     y2 += vgridspace;
  2244.    }
  2245.    x1 = max(0,x1);
  2246.    y1 = max(0,y1);
  2247.    pgeptr = page_ptr;
  2248.    for(vmus = vgridspace;vmus < vpage_size;vmus += vgridspace)
  2249.    {
  2250.         if(!clip || (vmus >= y1 && vmus <= y2))
  2251.         {
  2252.        for(hmus = hgridspace;hmus < hpage_size;hmus += hgridspace)
  2253.        {
  2254.           if(!clip || (hmus >= x1 && hmus <= x2))
  2255.           {
  2256.              mutopage(hmus,vmus,&xpos,&ypos,1);
  2257.              put_mpix(xpos,ypos,bytes_line);
  2258.           }
  2259.        }
  2260.         }
  2261.    }
  2262. }
  2263.  
  2264.  
  2265.  
  2266.  
  2267. /**************************************************************************/
  2268. /* Function: put_mpix()                              */
  2269. /* Description: Put grid pixel in memory buffer                  */ 
  2270. /**************************************************************************/
  2271. put_mpix(x,y,bytes_line)
  2272. int x,y;
  2273. int bytes_line;
  2274. {
  2275.    char *ptr;
  2276.    register long offset;
  2277.  
  2278.  
  2279.    offset = page_ptr;
  2280.  
  2281.    offset += (long)((long)bytes_line*(long)y);
  2282.    offset += (long)(x/8);
  2283.    ptr = (char *)offset;
  2284.    *ptr |= pixtbl[x%8];
  2285. }
  2286.  
  2287.  
  2288.  
  2289.  
  2290. /**************************************************************************/
  2291. /* Function: calc_size_fit()                          */
  2292. /* Description: Calc page size for size to fit and PADJCNT          */
  2293. /**************************************************************************/
  2294. calc_size_fit(item)
  2295. int item;
  2296. {
  2297.     int hwidth;
  2298.     int pixw;
  2299.      int pixh;
  2300.  
  2301.     pixw = hmupix(hpage_size);
  2302.     pixh = vmupix(vpage_size);    
  2303.         hwidth = ((item == PADJCNT) ? (pixw * 2) : (pixw));
  2304.     if(dpwork.g_w <= scaler(dpwork.g_h,hwidth,pixh))
  2305.     {
  2306.         pagew = dpwork.g_w;
  2307.         pageh = scaler(dpwork.g_w,pixh,hwidth);
  2308.     }
  2309.     else
  2310.     {
  2311.         pageh = dpwork.g_h;
  2312.         pagew = scaler(dpwork.g_h,hwidth,pixh);
  2313.         pageh = dpwork.g_h = scaler(pagew,pixh,hwidth);
  2314.     }
  2315.         pxy[0] = dpwork.g_x;
  2316.         pxy[1] = dpwork.g_y;
  2317.     pxy[2] = dpwork.g_x + pagew - 1;
  2318.     pxy[3] = dpwork.g_y + pageh - 1;
  2319.  
  2320. }
  2321.  
  2322.  
  2323.  
  2324.  
  2325. /**************************************************************************/
  2326. /* Function: redraw_alt()                          */
  2327. /* Description: Redraw Handler for PADJCNT                  */
  2328. /**************************************************************************/
  2329. redraw_alt()
  2330. {
  2331.    int endflag;
  2332.    int g_flag;                /* graphic region? */
  2333.    int pxy[4];
  2334.    int rtemp_page;
  2335.    int tpage;
  2336.  
  2337.    PAGE *rpagehd;
  2338.    PAGE *rcurpage;
  2339.    ARTICLE *rarthd;
  2340.  
  2341.    if(tmplate_flag)
  2342.    {
  2343.       rpagehd = pagehd;
  2344.       rcurpage = curpage;
  2345.       rarthd   = arthd;
  2346.    }
  2347.  
  2348.    endflag = 0;
  2349.    if((!blit_flag) || mode_change)
  2350.    {
  2351.       clrmem(page_ptr,pagebytes);
  2352.  
  2353.       pxy[1] = 0;
  2354.       pxy[3] = pageh-1;
  2355.  
  2356.       if(show_grids)
  2357.     do_grids(0,0,0,0,0);
  2358.  
  2359.       rtemp_page = curr_page;
  2360.       tpage = ((curr_page % 2) ? (curr_page - 1) : (curr_page));
  2361.       for(curr_page = tpage;curr_page <= tpage+1;curr_page++)
  2362.       {
  2363.       if(tmplate_flag)
  2364.           {
  2365.         if(curr_page == -2)
  2366.         {
  2367.           pagehd = curpage = left_tmplate;
  2368.           arthd  = ltarthd;
  2369.         }
  2370.         else
  2371.         {
  2372.           pagehd = curpage = right_tmplate;
  2373.           arthd = rtarthd;
  2374.         }
  2375.           
  2376.           }
  2377.  
  2378.           display_template(1,0L);
  2379.  
  2380.           region_ptr = get_fregion(curr_page,
  2381.             &rect_in_mu[0],&rect_in_mu[1],
  2382.             &rect_in_mu[2],&rect_in_mu[3],&g_flag);
  2383.  
  2384.           while(region_ptr)
  2385.           {
  2386.              if(rect_in_mu[0] >= hpage_size)
  2387.                     goto next;
  2388.  
  2389.           mclip();
  2390.              if(!g_flag)
  2391.                 get_txtattr(region_ptr,&gltxtattr);
  2392.          else
  2393.             get_grattr(region_ptr,glgrattr);
  2394.          if(g_flag || !mode_flag)
  2395.          {
  2396.                 opcode = get_fprimitive(region_ptr,&count,&wmode);
  2397.                 while(opcode != -1)
  2398.                 {
  2399.               switch(opcode)
  2400.               {
  2401.                case 3:
  2402.                 case 4:
  2403.                 case 0: redraw_polygon(count,wmode,g_flag);
  2404.                             break;
  2405.  
  2406.             case 1: redraw_ellipse(wmode,g_flag);
  2407.                     break;
  2408.  
  2409.                 case 2: graphic_setup();
  2410.                           break;
  2411.               }
  2412.                   opcode = get_nprimitive(&count,&wmode);
  2413.                 }
  2414.         }
  2415.             if(mode_flag && !g_flag)
  2416.         {
  2417.            if(txtptr = get_txtptr(region_ptr))
  2418.                {
  2419.           if(*txtptr)
  2420.           {
  2421.                  get_buffvars(region_ptr);
  2422.              open_region(region_ptr);
  2423.                      do_regoutput(txtptr,&endflag);
  2424.                      put_buffvars(region_ptr);
  2425.           }
  2426.                }
  2427.            GDvq_extnd(mhandle,0,intout,mxres,myres,&page_ptr);        
  2428.             }
  2429. next:        region_ptr = get_nregion(&rect_in_mu[0],&rect_in_mu[1],
  2430.                            &rect_in_mu[2],&rect_in_mu[3],&g_flag);
  2431.      } /* while region_ptr */
  2432.          display_template(2,0L);
  2433.      do_numbers(0L,0);
  2434.        }   /* for(curr_page =temp_page;curr_page <= temp_page+1;curr_page++)*/
  2435.  
  2436.        set_clip(TRUE,&dpwork);
  2437.         if(view_size == PADJCNT)
  2438.         {
  2439.       vsl_type(mhandle,1);
  2440.       vsl_width(mhandle,1);
  2441.       vsl_ends(mhandle,0,0);
  2442.           pxy[0] = pxy[2] = pagew/2;
  2443.           pxy[1] = 0;
  2444.           pxy[3] = pageh;
  2445.           v_pline(mhandle,2,pxy);
  2446.         }
  2447.         mode_change = FALSE;
  2448.         curr_page = rtemp_page;    
  2449.     alt_offset = ((curr_page % 2) ? (1) : (0));
  2450.      }               /*if((!blit_flag) || mode_change)*/
  2451.    do_blit();            /* Either blit now or redraw,then blit*/
  2452.    if(tmplate_flag)
  2453.    {
  2454.      pagehd = rpagehd;
  2455.      curpage = rcurpage;
  2456.      arthd   = rarthd;
  2457.    }
  2458. }
  2459.  
  2460. /************************************************************************/
  2461. /*                                    */
  2462. /*    In:    Pointer to graphic region to repel around        */
  2463. /*        x1,y1,x2,y2, bounding rectangle in mus of this region   */
  2464. /*                                    */
  2465. /*    Builds graphic region using scanner mem driver into another     */
  2466. /*    scan buffer. Assumes scan buffer already has masks drawn into   */
  2467. /*    it so display list can now be cleared.  Blit to a smaller buffer*/
  2468. /*    then call buildmask to build actual mask.  AND this buffer into */
  2469. /*        the original scan buffer to create repel effect            */
  2470. /************************************************************************/
  2471. repel_images(region_ptr,mux1,muy1,mux2,muy2,repoffset,buffaddr)
  2472. long region_ptr;
  2473. int mux1,muy1,mux2,muy2;
  2474. int repoffset;
  2475. long *buffaddr;
  2476. {
  2477.    long tmp_scanbuf;
  2478.    long maskbuf;
  2479.    int count,wmode,opcode;
  2480.    int tmpmode;
  2481.    int tmpprint;
  2482.    int x1,y1,x2,y2;
  2483.    int width,height;
  2484.    FDB scanmfdb;
  2485.    FDB maskmfdb;
  2486.    int pxy[8];
  2487.    int hoffset,voffset;
  2488.    int nrect[4];
  2489.    int oldwidth,oldheight;
  2490.    int newwidth,newheight;
  2491.    register int i;
  2492.    int odeltax,ndeltax,odeltay,ndeltay;
  2493.    int byte_width;
  2494.    long bufsize;
  2495.  
  2496.    hoffset = repoffset * 18;
  2497.    voffset = repoffset * 16;        /* Convert to mus */
  2498.  
  2499.    nrect[0] = mux1 - hoffset;
  2500.    nrect[1] = muy1 - voffset;
  2501.    nrect[2] = mux2 + hoffset;
  2502.    nrect[3] = muy2 + voffset;
  2503.  
  2504.    mutomem(nrect[0],nrect[1],&x1,&y1);
  2505.    mutomem(nrect[2],nrect[3],&x2,&y2);
  2506.    if(x1 < 0)
  2507.     x1 = 0;
  2508.    if(y1 < 0)
  2509.     y1 = 0;
  2510.    if(x2 > scan_xres)
  2511.     x2 = scan_xres;
  2512.    if(y2 > scan_yres)
  2513.     y2 = scan_yres;
  2514.    width = x2 - x1 + 1;
  2515.    height = y2 - y1 + 1;
  2516.    scanmfdb.fd_w = scan_xres;
  2517.    maskmfdb.fd_w = width;
  2518.    scanmfdb.fd_h = scan_yres;
  2519.    maskmfdb.fd_h = height;
  2520.    scanmfdb.fd_wdwidth = (scan_xres + 15)/16;
  2521.    maskmfdb.fd_wdwidth = (width + 15)/16;
  2522.    scanmfdb.fd_stand = maskmfdb.fd_stand = 0;
  2523.    scanmfdb.fd_nplanes = maskmfdb.fd_nplanes = 1;
  2524.    if(*buffaddr)
  2525.    {
  2526.       scanmfdb.fd_addr = scanptr;
  2527.       maskmfdb.fd_addr = *buffaddr;
  2528.    }    
  2529.    else
  2530.    {
  2531.       oldwidth = mux2 - mux1 + 1;
  2532.       oldheight = muy2 - muy1 + 1;
  2533.       newwidth = nrect[2] - nrect[0] + 1;
  2534.       newheight = nrect[3] - nrect[1] + 1;
  2535.       maskbuf = get_lcmem((long)((long)height * ((((long)width+7)/8)+1)));
  2536.       tmpmode = mode_flag;
  2537.       tmpprint = print_flag;
  2538.       tmp_scanbuf = scanptr;
  2539.       scanptr = get_lcmem((long)((long)scan_yres * ((((long)scan_xres+7)/8)+1)));
  2540.  
  2541.       byte_width = ((width+2+15)/16)*2;
  2542.       bufsize = (long)byte_width * (long)(height + 2);
  2543.       newscreen = (((realscreen = (long)get_lcmem(bufsize + 512)) + 512)
  2544.                 &0xFFFFFE00L);
  2545.       if(!scanptr || !maskbuf || !newscreen)
  2546.       {
  2547.      if(!alerted)
  2548.      {
  2549.         alerted = 1;
  2550.           alert_cntre(ALERT31);
  2551.      }
  2552.      scanptr = tmp_scanbuf;
  2553.      return;
  2554.       }     
  2555.      
  2556.       GDvq_extnd(mhandle,0,intout,scan_xres,scan_yres,&scanptr);
  2557.       scanmfdb.fd_addr = scanptr;
  2558.       maskmfdb.fd_addr = maskbuf;
  2559.  
  2560.       pxy[0] = x1;
  2561.       pxy[1] = y1;
  2562.       pxy[2] = x2;
  2563.       pxy[3] = y2;
  2564.       pxy[4] = pxy[5] = 0;
  2565.       pxy[6] = width - 1;
  2566.       pxy[7] = height - 1;
  2567.  
  2568.       mode_flag = TRUE;
  2569.       print_flag = 2;
  2570.       opcode = get_fprimitive(region_ptr,&count,&wmode);
  2571.              while(opcode != -1)
  2572.              {
  2573.             switch(opcode)
  2574.             {
  2575.            case 3:
  2576.                case 4:
  2577.                case 0:
  2578.                i=0;
  2579.                while(i<count*2)
  2580.                {
  2581.                    odeltax = ptsarray[i] - mux1;
  2582.                    ndeltax = scaler(odeltax,newwidth,
  2583.                     oldwidth); 
  2584.                    ptsarray[i++] = nrect[0] + ndeltax;
  2585.  
  2586.                    odeltay = ptsarray[i] - muy1;
  2587.                    ndeltay = scaler(odeltay,newheight,
  2588.                     oldheight);
  2589.                    ptsarray[i++] = nrect[1] + ndeltay;
  2590.                } 
  2591.                redraw_polygon(count,wmode,0);
  2592.                            break;
  2593.  
  2594.            case 1: 
  2595.                     case12_scale(mux1,muy1,
  2596.                          oldwidth,oldheight,
  2597.                          nrect[0],
  2598.                          nrect[1],
  2599.                          newwidth,
  2600.                          newheight,1);
  2601.                 redraw_ellipse(wmode,0);
  2602.                    break;
  2603.  
  2604.            case 2: 
  2605.                     case12_scale(mux1,muy1,
  2606.                          oldwidth,oldheight,
  2607.                          nrect[0],
  2608.                          nrect[1],
  2609.                          newwidth,
  2610.                          newheight,2);
  2611.                insert_graphic();
  2612.                      break;
  2613.             }
  2614.                 opcode = get_nprimitive(&count,&wmode);
  2615.              }
  2616.       vro_cpyfm(shandle,3,pxy,&scanmfdb,&maskmfdb);
  2617.       buildmsk(maskbuf,width,height);
  2618.       free(scanptr);
  2619.       scanptr = tmp_scanbuf;   
  2620.       GDvq_extnd(mhandle,0,intout,scan_xres,scan_yres,&scanptr);
  2621.       scanmfdb.fd_addr = scanptr;
  2622.       mode_flag = tmpmode;
  2623.       print_flag = tmpprint;
  2624.       set_repbuff(region_ptr,maskbuf);
  2625.    }
  2626.  
  2627.    pxy[0] = pxy[1] = 0;
  2628.    pxy[2] = width - 1;
  2629.    pxy[3] = height - 1;
  2630.    pxy[4] = x1;
  2631.    pxy[5] = y1;
  2632.    pxy[6] = x2;
  2633.    pxy[7] = y2;
  2634.    vro_cpyfm(shandle,1,pxy,&maskmfdb,&scanmfdb);    /* "AND" blt */
  2635.  
  2636. }
  2637.  
  2638.  
  2639. buildmsk(srcbuf,xres,yres)
  2640. long srcbuf;
  2641. register int xres,yres;
  2642. {
  2643.    FDB srcmfdb;
  2644.    FDB desmfdb;
  2645.    int clip[4];
  2646.    int pts[8];
  2647.    int byte_width;
  2648.    long bufsize;
  2649.    long screen;
  2650.    int attr[5];
  2651.  
  2652.    gsx_moff();   
  2653.    vqf_attributes(shandle,attr);
  2654.    vsf_interior(shandle,1);        /* Solid fills for seed fill */
  2655.    screen = Logbase();
  2656.  
  2657.    byte_width = ((xres+2+15)/16)*2;
  2658.    bufsize = (long)byte_width * (long)(yres + 2);
  2659.  
  2660.    srcmfdb.fd_addr = srcbuf;
  2661.    desmfdb.fd_addr = newscreen;
  2662.    srcmfdb.fd_w = xres;
  2663.    desmfdb.fd_w = xres + 2;
  2664.    srcmfdb.fd_h = yres;
  2665.    desmfdb.fd_h = yres + 2;
  2666.    srcmfdb.fd_wdwidth = (xres + 15)/16;
  2667.    desmfdb.fd_wdwidth = (xres + 2 + 15)/16;
  2668.    srcmfdb.fd_stand = desmfdb.fd_stand = 0;
  2669.    srcmfdb.fd_nplanes = desmfdb.fd_nplanes = 1;
  2670.  
  2671.    pts[0] = 0;
  2672.    pts[1] = 0;
  2673.    pts[2] = xres - 1;
  2674.    pts[3] = yres - 1;
  2675.    pts[4] = 1;
  2676.    pts[5] = 1;
  2677.    pts[6] = xres;
  2678.    pts[7] = yres;
  2679.  
  2680.    vro_cpyfm(shandle,3,pts,&srcmfdb,&desmfdb);
  2681.  
  2682.    setvdi(xres+2,yres+2,byte_width);        /* Set vdi variables */
  2683.  
  2684.    Setscreen(newscreen,-1L,-1L);
  2685.    clip[0] = 0;
  2686.    clip[1] = 0;
  2687.    clip[2] = xres+1;
  2688.    clip[3] = yres+1;
  2689.    vs_clip(shandle,1,clip);   
  2690.  
  2691.    v_contourfill(shandle,0,0,1);
  2692.    vro_cpyfm(shandle,6,pts,&srcmfdb,&desmfdb);
  2693.    pts[0] += 1;
  2694.    pts[1] += 1;
  2695.    pts[2] += 1;
  2696.    pts[3] += 1;
  2697.    pts[4] -= 1;
  2698.    pts[5] -= 1;
  2699.    pts[6] -= 1;
  2700.    pts[7] -= 1;
  2701.    vro_cpyfm(shandle,3,pts,&desmfdb,&srcmfdb);
  2702.    fixvdi();
  2703.    Setscreen(screen,-1L,-1L);
  2704.  
  2705.    vs_clip(shandle,0,clip);
  2706.    vsf_interior(shandle,attr[0]);
  2707.    free(realscreen);
  2708.    gsx_mon();
  2709. }
  2710.  
  2711.  
  2712. free_repbuffs()
  2713. {
  2714.    register long region_ptr;
  2715.    int g_flag;
  2716.    int rect[4];
  2717.    long tmppage;
  2718.  
  2719.    tmppage = curpage;   
  2720.    region_ptr = get_fregion(curr_page,
  2721.             &rect[0],&rect[1],
  2722.             &rect[2],&rect[3],&g_flag);
  2723.    while(region_ptr)
  2724.    {
  2725.     if(g_flag)
  2726.         clr_grbuff(region_ptr);
  2727.         region_ptr = get_nregion(&rect[0],&rect[1],
  2728.                         &rect[2],&rect[3],&g_flag);
  2729.     }
  2730.     curpage = tmppage;
  2731. }
  2732.  
  2733.  
  2734.  
  2735. display_template(num,rgrect)
  2736. int num;
  2737. register int rgrect[];
  2738. {
  2739.   int endflag;
  2740.   int g_flag;                /* graphic region? */
  2741.   PAGE *rpagehd;
  2742.   PAGE *rcurpage;
  2743.   int  rtemp_page;
  2744.   ARTICLE *rarthd;
  2745.   int tgrect[4];
  2746.   int tpxy[4];
  2747.   int rectmu[4];
  2748.   char *tptr;
  2749.  
  2750.   if(disp_pos)                /* display in back */
  2751.   {
  2752.      if(num != 1)            /* so goes first   */
  2753.        return;
  2754.   }
  2755.   else
  2756.   {
  2757.      if(num != 2)
  2758.        return;
  2759.   }
  2760.  
  2761.   if(!tmplate_flag && displ_tmpl_flag)  
  2762.   {
  2763.     rpagehd = pagehd;
  2764.     rcurpage = curpage;
  2765.     rarthd   = arthd;
  2766.  
  2767.     switch(disp_type)
  2768.     {
  2769.       case 0: /* both */
  2770.           pagehd=curpage=((curr_page%2)?(right_tmplate):(left_tmplate));
  2771.           arthd = ((curr_page%2)?(rtarthd):(ltarthd));
  2772.           break;
  2773.       case 1: /* left only */
  2774.           pagehd = curpage = left_tmplate;
  2775.           arthd  = ltarthd;
  2776.           break;
  2777.       case 2: /* right only */
  2778.           pagehd = curpage = right_tmplate;
  2779.           arthd = rtarthd;
  2780.           break;
  2781.     }
  2782.  
  2783.     rtemp_page = curr_page;
  2784.     curr_page = curpage->pagenum;
  2785.  
  2786.     endflag = 0;
  2787.  
  2788.     region_ptr = get_fregion(curr_page,
  2789.                 &rectmu[0],&rectmu[1],
  2790.             &rectmu[2],&rectmu[3],&g_flag);
  2791.  
  2792.  
  2793.     while(region_ptr)
  2794.     {
  2795.  
  2796.        if((view_size == PADJCNT) && !print_flag && disp_type)
  2797.                     curr_page = rtemp_page;
  2798.  
  2799.        if(rectmu[0] >= hpage_size)
  2800.                 goto next;
  2801.  
  2802.         if(rgrect)
  2803.     {
  2804.            mutopage(rectmu[0],rectmu[1],&tpxy[0],&tpxy[1],0);
  2805.            mutopage(rectmu[2],rectmu[3],&tpxy[2],&tpxy[3],0);
  2806.  
  2807.        tgrect[0] = tpxy[0];
  2808.            tgrect[1] = tpxy[1];
  2809.            tgrect[2] = tpxy[2] - tpxy[0] + 1;
  2810.            tgrect[3] = tpxy[3] - tpxy[1] + 1;
  2811.         }
  2812.  
  2813.         if(!rgrect || rc_intersect(rgrect,tgrect))
  2814.     {
  2815.       if((!rgrect) && (print_flag != 1))
  2816.               mclip();
  2817.  
  2818.           if(!g_flag)
  2819.           {
  2820.              get_txtattr(region_ptr,&gltxtattr);
  2821.          if(mode_flag)
  2822.          {
  2823.             GDvq_extnd(mhandle,0,intout,scan_xres,scan_yres,&scanptr);
  2824.         if(!rgrect)
  2825.                     scan_clip();
  2826.             clrmem(scanptr,scan_bytes);
  2827.          }
  2828.           }
  2829.       else 
  2830.          get_grattr(region_ptr,glgrattr);
  2831.  
  2832.       if(g_flag || !mode_flag)
  2833.           {        
  2834.             opcode = get_fprimitive(region_ptr,&count,&wmode);
  2835.             while(opcode != -1)
  2836.             {
  2837.           switch(opcode)
  2838.           {
  2839.             case 3:
  2840.             case 4:
  2841.             case 0: redraw_polygon(count,wmode,g_flag);
  2842.                         break;
  2843.  
  2844.             case 1: redraw_ellipse(wmode,g_flag);
  2845.                     break;
  2846.  
  2847.             case 2: graphic_setup();
  2848.                   break;
  2849.           }
  2850.               opcode = get_nprimitive(&count,&wmode);
  2851.             }
  2852.           }
  2853.        
  2854.           if(mode_flag && !g_flag)
  2855.       {
  2856.         if(txtptr = get_txtptr(region_ptr))
  2857.             {
  2858.            if(*txtptr)
  2859.            {
  2860.           if(!rgrect)
  2861.           {
  2862.                 get_buffvars(region_ptr);
  2863.                 open_region(region_ptr);
  2864.             do_regoutput(txtptr,&endflag);
  2865.                     put_buffvars(region_ptr);
  2866.           }
  2867.           else
  2868.           {
  2869.              open_region(region_ptr);
  2870.                      do_clipregout(tgrect[0],tgrect[1],
  2871.             tgrect[2] + tgrect[0] - 1,
  2872.             tgrect[3] + tgrect[1] - 1);
  2873.           }
  2874.            }
  2875.             }
  2876.         if(print_flag != 1)              /* Don't do this for printing only */
  2877.                 GDvq_extnd(mhandle,0,intout,mxres,myres,&page_ptr);
  2878.           }
  2879.     }
  2880. next:   region_ptr = get_nregion(&rectmu[0],&rectmu[1],
  2881.                               &rectmu[2],&rectmu[3],&g_flag);
  2882.  
  2883.         if((view_size == PADJCNT) && !print_flag && disp_type)
  2884.                     rtemp_page = curr_page;
  2885.  
  2886.    }
  2887.    pagehd    = rpagehd;
  2888.    curpage   = rcurpage;
  2889.    curr_page = rtemp_page;
  2890.    arthd     = rarthd;
  2891.   }
  2892. }
  2893.  
  2894.  
  2895.  
  2896.  
  2897. tdo_template(num)
  2898. int num;
  2899. {
  2900.   int endflag;
  2901.   int g_flag;                /* graphic region? */
  2902.   PAGE *rpagehd;
  2903.   PAGE *rcurpage;
  2904.   int  rtemp_page;
  2905.   ARTICLE *rarthd;
  2906.   int rectmu[4];
  2907.  
  2908.   if(disp_pos)                /* display in back */
  2909.   {
  2910.      if(num != 1)            /* so goes first   */
  2911.        return;
  2912.   }
  2913.   else
  2914.   {
  2915.      if(num != 2)
  2916.        return;
  2917.   }
  2918.  
  2919.   if(!tmplate_flag && displ_tmpl_flag)  
  2920.   {
  2921.     rpagehd = pagehd;
  2922.     rcurpage = curpage;
  2923.     rarthd   = arthd;
  2924.  
  2925.     switch(disp_type)
  2926.     {
  2927.       case 0: /* both */
  2928.           pagehd=curpage=((curr_page%2)?(right_tmplate):(left_tmplate));
  2929.           arthd = ((curr_page%2)?(rtarthd):(ltarthd));
  2930.           break;
  2931.       case 1: /* left only */
  2932.           pagehd = curpage = left_tmplate;
  2933.           arthd  = ltarthd;
  2934.           break;
  2935.       case 2: /* right only */
  2936.           pagehd = curpage = right_tmplate;
  2937.           arthd = rtarthd;
  2938.           break;
  2939.     }
  2940.  
  2941.     rtemp_page = curr_page;
  2942.     curr_page = curpage->pagenum;
  2943.  
  2944.     endflag = 0;
  2945.  
  2946.     region_ptr = get_fregion(curr_page,
  2947.                 &rectmu[0],&rectmu[1],
  2948.             &rectmu[2],&rectmu[3],&g_flag);
  2949.     while(region_ptr)
  2950.     {
  2951.       cpabt = 0;            /* CJG 08/26/89 */
  2952.           if(rectmu[0] >= hpage_size)
  2953.                 goto next;
  2954.  
  2955.           if(!g_flag)
  2956.              get_txtattr(region_ptr,&gltxtattr);
  2957.       else 
  2958.          get_grattr(region_ptr,glgrattr);
  2959.  
  2960.       if(g_flag)
  2961.           {        
  2962.             opcode = get_fprimitive(region_ptr,&count,&wmode);
  2963.             while(opcode != -1)
  2964.             {
  2965.           switch(opcode)
  2966.           {
  2967.             case 3:
  2968.             case 4:
  2969.             case 0:
  2970.             case 1:  TYF_Gtype = 5;
  2971.                     calc_prim(opcode,&TYF_Gx0,&TYF_Gy0,
  2972.                     &TYF_Gx1,&TYF_Gy1,count);
  2973.                  insGR_TYF(opcode,count,glgrattr);
  2974.                   break;
  2975.             case 2:  TYF_Gfile = (char *)&ptsarray[5];
  2976.                  TYF_Gx0 = ptsarray[0];
  2977.                  TYF_Gy0 = ptsarray[1];
  2978.                  TYF_Gx1 = ptsarray[2];
  2979.                  TYF_Gy1 = ptsarray[3];
  2980.                  switch(ptsarray[4])
  2981.                  {
  2982.                 case 0:
  2983.                    TYF_Gtype = 2;
  2984.                    break;
  2985.                 case 1:
  2986.                    TYF_Gtype = 3;
  2987.                    break;
  2988.                 case 2:
  2989.                    TYF_Gtype = 1;
  2990.                    break;
  2991.                     case 3:
  2992.                    TYF_Gtype = 4;
  2993.                    break;
  2994.                  }
  2995.                  insGR_TYF(opcode,count,glgrattr);
  2996.                  break;
  2997.           }
  2998.               opcode = get_nprimitive(&count,&wmode);
  2999.             } /* while */
  3000.           }   /* if g_flag */
  3001.        
  3002.           if(!g_flag)
  3003.       {
  3004.         if(txtptr = get_txtptr(region_ptr))
  3005.             {
  3006.            if(*txtptr)
  3007.            {
  3008.           get_buffvars(region_ptr);
  3009.           open_region(region_ptr);
  3010.           do_tdoout(txtptr,&endflag);
  3011.            }
  3012.             }
  3013.           }
  3014.  
  3015. next:   region_ptr = get_nregion(&rectmu[0],&rectmu[1],
  3016.                               &rectmu[2],&rectmu[3],&g_flag);
  3017.     }
  3018.    pagehd    = rpagehd;
  3019.    curpage   = rcurpage;
  3020.    curr_page = rtemp_page;
  3021.    arthd     = rarthd;
  3022.   }
  3023. }
  3024.  
  3025. redraw_spot(rptr,murect,bltflag)
  3026. register REGION *rptr;
  3027. register int murect[];
  3028. int bltflag;
  3029. {
  3030.    int g_flag;                /* graphic region? */
  3031.    int rgrect[4];
  3032.    int tgrect[4];
  3033.    int rpxy[4];
  3034.    int tpxy[4];
  3035.    int murec1[4];
  3036.    int pts;
  3037.  
  3038.    int xoffset,yoffset;
  3039.  
  3040.    if(!rptr)
  3041.    {
  3042.     pts = 36;
  3043.     xoffset = pts * 18;
  3044.     yoffset = pts * 16;
  3045.    }    
  3046.    else
  3047.    {
  3048.     pts = rptr->grattr[1];
  3049.         if(pts && (rptr->grattr[2] & 0x8000))
  3050.         {
  3051.        xoffset = pts * 18;
  3052.        yoffset = pts * 16;
  3053.         }
  3054.         else
  3055.     {
  3056.        xoffset = 162; /* offsets are in machine units */
  3057.        yoffset = 144; /* an eighth of a inch each way*/
  3058.     }
  3059.    }
  3060.  
  3061.    murect[0] -= xoffset;
  3062.    murect[1] -= yoffset;
  3063.    murect[2] += xoffset;
  3064.    murect[3] += yoffset;
  3065.  
  3066.    
  3067.    GDvq_extnd(mhandle,0,intout,mxres,myres,&page_ptr);
  3068.  
  3069.    mutopage(murect[0],murect[1],&rpxy[0],&rpxy[1],1);
  3070.    mutopage(murect[2],murect[3],&rpxy[2],&rpxy[3],1);
  3071. #if NEVER
  3072.    rpxy[0] -= 2;        /* With solid fills perimeter is on */
  3073.    rpxy[1] -= 2;        /* so when erasing with hollow fill */
  3074.    rpxy[2] += 2;        /* we must ......            */
  3075.    rpxy[3] += 2;        /* Adjust for perimeter being off   */
  3076. #endif
  3077.    rpxy[0] = max(0,rpxy[0]);
  3078.    rpxy[1] = max(0,rpxy[1]);
  3079.    rpxy[2] = min(pagew - 1,rpxy[2]);
  3080.    rpxy[3] = min(pageh - 1,rpxy[3]);
  3081.  
  3082.    vs_clip(mhandle,1,rpxy);
  3083.    write_white(mhandle);
  3084.    v_bar(mhandle,rpxy);
  3085.    write_black(mhandle);
  3086.  
  3087.    rgrect[0] = rpxy[0];
  3088.    rgrect[1] = rpxy[1];
  3089.    rgrect[2] = rpxy[2] - rpxy[0] + 1;
  3090.    rgrect[3] = rpxy[3] - rpxy[1] + 1;
  3091.  
  3092.    if(show_grids)    /* moved it here cjg */
  3093.     do_grids(1,murect[0],murect[1],murect[2],murect[3]);
  3094.  
  3095.    display_template(1,rgrect);
  3096.    
  3097.    region_ptr = get_fregion(curr_page,
  3098.     &murec1[0],&murec1[1],
  3099.     &murec1[2],&murec1[3],&g_flag);
  3100.    while(region_ptr)
  3101.    {
  3102.      if(murec1[0] >= hpage_size)
  3103.             goto next;
  3104.  
  3105.      if(rptr != region_ptr)
  3106.      {
  3107.         mutopage(murec1[0],murec1[1],&tpxy[0],&tpxy[1],0);
  3108.         mutopage(murec1[2],murec1[3],&tpxy[2],&tpxy[3],0);
  3109.     
  3110.     tgrect[0] = tpxy[0];
  3111.         tgrect[1] = tpxy[1];
  3112.         tgrect[2] = tpxy[2] - tpxy[0] + 1;
  3113.         tgrect[3] = tpxy[3] - tpxy[1] + 1;
  3114.     
  3115.     if(rc_intersect(rgrect,tgrect))
  3116.     {
  3117.        if(g_flag)
  3118.                get_grattr(region_ptr,glgrattr);
  3119.  
  3120.            if(g_flag || !mode_flag)
  3121.            {
  3122.                opcode = get_fprimitive(region_ptr,&count,&wmode);
  3123.                while(opcode != -1)
  3124.                {
  3125.                    switch(opcode)
  3126.                    {
  3127.                    case 3:
  3128.                    case 4:
  3129.                    case 0: redraw_polygon(count,wmode,g_flag);
  3130.                                break;
  3131.  
  3132.                case 1: redraw_ellipse(wmode,g_flag);
  3133.                        break;
  3134.  
  3135.                case 2: graphic_setup();
  3136.                          break;
  3137.                 }
  3138.                     opcode = get_nprimitive(&count,&wmode);
  3139.                }
  3140.        }
  3141.            if(mode_flag && !g_flag)
  3142.        {
  3143.           if(txtptr = get_txtptr(region_ptr))
  3144.               {
  3145.               if(*txtptr)
  3146.           {
  3147.                  open_region(region_ptr);
  3148.                      do_clipregout(tgrect[0],tgrect[1],
  3149.             tgrect[2] + tgrect[0] - 1,
  3150.             tgrect[3] + tgrect[1] - 1);
  3151.                   }
  3152.           }
  3153.            }
  3154.     }
  3155.       }
  3156. next: region_ptr = get_nregion(&murec1[0],&murec1[1],
  3157.                     &murec1[2],&murec1[3],&g_flag);
  3158.    }
  3159.  
  3160.    display_template(2,rgrect);
  3161.    do_numbers(rgrect,0);
  3162.  
  3163.    if(bltflag)
  3164.    {
  3165.       mclip();
  3166.       do_blit();
  3167.    }
  3168.  
  3169. }
  3170.